Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.espertech.esper.compiler.internal.generated.EsperEPL2GrammarParser Maven / Gradle / Ivy
// Generated from EsperEPL2Grammar.g by ANTLR 4.9.3
/*
***************************************************************************************
* Copyright (C) 2006 EsperTech, Inc. All rights reserved. *
* http://www.espertech.com/esper *
* http://www.espertech.com *
* ---------------------------------------------------------------------------------- *
* The software in this package is published under the terms of the GPL license *
* a copy of which has been included with this distribution in the license.txt file. *
***************************************************************************************
*/
package com.espertech.esper.compiler.internal.generated;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class EsperEPL2GrammarParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
CREATE=1, WINDOW=2, IN_SET=3, BETWEEN=4, LIKE=5, REGEXP=6, ESCAPE=7, OR_EXPR=8,
AND_EXPR=9, NOT_EXPR=10, EVERY_EXPR=11, EVERY_DISTINCT_EXPR=12, WHERE=13,
AS=14, SUM=15, AVG=16, MAX=17, MIN=18, COALESCE=19, MEDIAN=20, STDDEV=21,
AVEDEV=22, COUNT=23, SELECT=24, CASE=25, ELSE=26, WHEN=27, THEN=28, END=29,
FROM=30, OUTER=31, INNER=32, JOIN=33, LEFT=34, RIGHT=35, FULL=36, ON=37,
IS=38, BY=39, GROUP=40, HAVING=41, DISTINCT=42, ALL=43, ANY=44, SOME=45,
OUTPUT=46, EVENTS=47, FIRST=48, LAST=49, INSERT=50, INTO=51, VALUES=52,
ORDER=53, ASC=54, DESC=55, RSTREAM=56, ISTREAM=57, IRSTREAM=58, SCHEMA=59,
UNIDIRECTIONAL=60, RETAINUNION=61, RETAININTERSECTION=62, PATTERN=63,
SQL=64, METADATASQL=65, PREVIOUS=66, PREVIOUSTAIL=67, PREVIOUSCOUNT=68,
PREVIOUSWINDOW=69, PRIOR=70, EXISTS=71, WEEKDAY=72, LW=73, INSTANCEOF=74,
TYPEOF=75, CAST=76, CURRENT_TIMESTAMP=77, DELETE=78, SNAPSHOT=79, SET=80,
VARIABLE=81, TABLE=82, UNTIL=83, AT=84, INDEX=85, TIMEPERIOD_YEAR=86,
TIMEPERIOD_YEARS=87, TIMEPERIOD_MONTH=88, TIMEPERIOD_MONTHS=89, TIMEPERIOD_WEEK=90,
TIMEPERIOD_WEEKS=91, TIMEPERIOD_DAY=92, TIMEPERIOD_DAYS=93, TIMEPERIOD_HOUR=94,
TIMEPERIOD_HOURS=95, TIMEPERIOD_MINUTE=96, TIMEPERIOD_MINUTES=97, TIMEPERIOD_SEC=98,
TIMEPERIOD_SECOND=99, TIMEPERIOD_SECONDS=100, TIMEPERIOD_MILLISEC=101,
TIMEPERIOD_MILLISECOND=102, TIMEPERIOD_MILLISECONDS=103, TIMEPERIOD_MICROSEC=104,
TIMEPERIOD_MICROSECOND=105, TIMEPERIOD_MICROSECONDS=106, BOOLEAN_TRUE=107,
BOOLEAN_FALSE=108, VALUE_NULL=109, ROW_LIMIT_EXPR=110, OFFSET=111, UPDATE=112,
MATCH_RECOGNIZE=113, MATCH_RECOGNIZE_PERMUTE=114, MEASURES=115, DEFINE=116,
PARTITION=117, MATCHES=118, AFTER=119, FOR=120, WHILE=121, USING=122,
MERGE=123, MATCHED=124, EXPRESSIONDECL=125, CLASSDECL=126, NEWKW=127,
START=128, CONTEXT=129, INITIATED=130, TERMINATED=131, DATAFLOW=132, CUBE=133,
ROLLUP=134, GROUPING=135, GROUPING_ID=136, SETS=137, EVENTPRECEDENCE=138,
FOLLOWMAX_BEGIN=139, FOLLOWED_BY=140, GOES=141, EQUALS=142, SQL_NE=143,
QUESTION=144, LPAREN=145, RPAREN=146, LBRACK=147, RBRACK=148, LCURLY=149,
RCURLY=150, COLON=151, COMMA=152, EQUAL=153, LNOT=154, BNOT=155, NOT_EQUAL=156,
DIV=157, DIV_ASSIGN=158, PLUS=159, PLUS_ASSIGN=160, INC=161, MINUS=162,
MINUS_ASSIGN=163, DEC=164, STAR=165, STAR_ASSIGN=166, MOD=167, MOD_ASSIGN=168,
GE=169, GT=170, LE=171, LT=172, BXOR=173, BXOR_ASSIGN=174, BOR=175, BOR_ASSIGN=176,
LOR=177, BAND=178, BAND_ASSIGN=179, LAND=180, SEMI=181, DOT=182, NUM_LONG=183,
NUM_DOUBLE=184, NUM_FLOAT=185, ESCAPECHAR=186, ESCAPEBACKTICK=187, ATCHAR=188,
HASHCHAR=189, WS=190, SL_COMMENT=191, ML_COMMENT=192, TICKED_STRING_LITERAL=193,
QUOTED_STRING_LITERAL=194, STRING_LITERAL=195, TRIPLEQUOTE=196, IDENT=197,
IntegerLiteral=198, FloatingPointLiteral=199;
public static final int
RULE_startEPLExpressionRule = 0, RULE_startEventPropertyRule = 1, RULE_startJsonValueRule = 2,
RULE_classDecl = 3, RULE_expressionDecl = 4, RULE_expressionDialect = 5,
RULE_expressionDef = 6, RULE_expressionLambdaDecl = 7, RULE_expressionTypeAnno = 8,
RULE_annotationEnum = 9, RULE_elementValuePairsEnum = 10, RULE_elementValuePairEnum = 11,
RULE_elementValueEnum = 12, RULE_elementValueArrayEnum = 13, RULE_eplExpression = 14,
RULE_contextExpr = 15, RULE_selectExpr = 16, RULE_onExpr = 17, RULE_onStreamExpr = 18,
RULE_updateExpr = 19, RULE_updateDetails = 20, RULE_onMergeExpr = 21,
RULE_mergeItem = 22, RULE_mergeMatched = 23, RULE_mergeMatchedItem = 24,
RULE_onMergeDirectInsert = 25, RULE_mergeUnmatched = 26, RULE_mergeUnmatchedItem = 27,
RULE_mergeInsert = 28, RULE_onSelectExpr = 29, RULE_onUpdateExpr = 30,
RULE_onSelectInsertExpr = 31, RULE_onSelectInsertFromClause = 32, RULE_outputClauseInsert = 33,
RULE_onDeleteExpr = 34, RULE_onSetExpr = 35, RULE_onSetAssignmentList = 36,
RULE_onSetAssignment = 37, RULE_onExprFrom = 38, RULE_createWindowExpr = 39,
RULE_createWindowExprModelAfter = 40, RULE_createIndexExpr = 41, RULE_createIndexColumnList = 42,
RULE_createIndexColumn = 43, RULE_createVariableExpr = 44, RULE_createTableExpr = 45,
RULE_createTableColumnList = 46, RULE_createTableColumn = 47, RULE_createColumnList = 48,
RULE_createColumnListElement = 49, RULE_createSelectionList = 50, RULE_createSelectionListElement = 51,
RULE_createSchemaExpr = 52, RULE_createSchemaDef = 53, RULE_fafDelete = 54,
RULE_fafUpdate = 55, RULE_fafInsert = 56, RULE_fafInsertRow = 57, RULE_createDataflow = 58,
RULE_gopList = 59, RULE_gop = 60, RULE_gopParams = 61, RULE_gopParamsItemList = 62,
RULE_gopParamsItem = 63, RULE_gopParamsItemMany = 64, RULE_gopParamsItemAs = 65,
RULE_gopOut = 66, RULE_gopOutItem = 67, RULE_gopOutTypeList = 68, RULE_gopOutTypeParam = 69,
RULE_gopOutTypeItem = 70, RULE_gopDetail = 71, RULE_gopConfig = 72, RULE_createContextExpr = 73,
RULE_createExpressionExpr = 74, RULE_createClassExpr = 75, RULE_createContextDetail = 76,
RULE_contextContextNested = 77, RULE_createContextChoice = 78, RULE_createContextDistinct = 79,
RULE_createContextRangePoint = 80, RULE_createContextFilter = 81, RULE_createContextPartitionItem = 82,
RULE_createContextCoalesceItem = 83, RULE_createContextGroupItem = 84,
RULE_createContextPartitionInit = 85, RULE_createContextPartitionTerm = 86,
RULE_createSchemaQual = 87, RULE_variantList = 88, RULE_variantListElement = 89,
RULE_intoTableExpr = 90, RULE_insertIntoExpr = 91, RULE_insertIntoEventPrecedence = 92,
RULE_columnList = 93, RULE_columnListKeywordAllowed = 94, RULE_fromClause = 95,
RULE_regularJoin = 96, RULE_outerJoinList = 97, RULE_outerJoin = 98, RULE_outerJoinIdent = 99,
RULE_outerJoinIdentPair = 100, RULE_whereClause = 101, RULE_selectClause = 102,
RULE_selectionList = 103, RULE_selectionListElement = 104, RULE_selectionListElementExpr = 105,
RULE_selectionListElementAnno = 106, RULE_streamSelector = 107, RULE_streamExpression = 108,
RULE_forExpr = 109, RULE_patternInclusionExpression = 110, RULE_databaseJoinExpression = 111,
RULE_methodJoinExpression = 112, RULE_viewExpressions = 113, RULE_viewExpressionWNamespace = 114,
RULE_viewExpressionOptNamespace = 115, RULE_viewWParameters = 116, RULE_groupByListExpr = 117,
RULE_groupByListChoice = 118, RULE_groupByCubeOrRollup = 119, RULE_groupByGroupingSets = 120,
RULE_groupBySetsChoice = 121, RULE_groupByCombinableExpr = 122, RULE_orderByListExpr = 123,
RULE_orderByListElement = 124, RULE_havingClause = 125, RULE_outputLimit = 126,
RULE_outputLimitAndTerm = 127, RULE_outputLimitAfter = 128, RULE_rowLimit = 129,
RULE_crontabLimitParameterSetList = 130, RULE_crontabLimitParameterSet = 131,
RULE_whenClause = 132, RULE_elseClause = 133, RULE_matchRecog = 134, RULE_matchRecogPartitionBy = 135,
RULE_matchRecogMeasures = 136, RULE_matchRecogMeasureItem = 137, RULE_matchRecogMatchesSelection = 138,
RULE_matchRecogPattern = 139, RULE_matchRecogMatchesAfterSkip = 140, RULE_matchRecogMatchesInterval = 141,
RULE_matchRecogPatternAlteration = 142, RULE_matchRecogPatternConcat = 143,
RULE_matchRecogPatternUnary = 144, RULE_matchRecogPatternNested = 145,
RULE_matchRecogPatternPermute = 146, RULE_matchRecogPatternAtom = 147,
RULE_matchRecogPatternRepeat = 148, RULE_matchRecogDefine = 149, RULE_matchRecogDefineItem = 150,
RULE_expression = 151, RULE_caseExpression = 152, RULE_evalOrExpression = 153,
RULE_evalAndExpression = 154, RULE_bitWiseExpression = 155, RULE_negatedExpression = 156,
RULE_evalEqualsExpression = 157, RULE_evalRelationalExpression = 158,
RULE_inSubSelectQuery = 159, RULE_concatenationExpr = 160, RULE_additiveExpression = 161,
RULE_multiplyExpression = 162, RULE_unaryExpression = 163, RULE_unaryMinus = 164,
RULE_substitutionCanChain = 165, RULE_newAssign = 166, RULE_rowSubSelectExpression = 167,
RULE_subSelectGroupExpression = 168, RULE_existsSubSelectExpression = 169,
RULE_subQueryExpr = 170, RULE_subSelectFilterExpr = 171, RULE_arrayExpression = 172,
RULE_builtinFunc = 173, RULE_firstLastWindowAggregation = 174, RULE_libFunctionNoClass = 175,
RULE_funcIdentChained = 176, RULE_libFunctionArgs = 177, RULE_libFunctionArgItem = 178,
RULE_betweenList = 179, RULE_patternExpression = 180, RULE_followedByExpression = 181,
RULE_followedByRepeat = 182, RULE_orExpression = 183, RULE_andExpression = 184,
RULE_matchUntilExpression = 185, RULE_qualifyExpression = 186, RULE_guardPostFix = 187,
RULE_distinctExpressionList = 188, RULE_distinctExpressionAtom = 189,
RULE_atomicExpression = 190, RULE_observerExpression = 191, RULE_guardWhereExpression = 192,
RULE_guardWhileExpression = 193, RULE_matchUntilRange = 194, RULE_eventFilterExpression = 195,
RULE_propertyExpression = 196, RULE_propertyExpressionAtomic = 197, RULE_propertyExpressionSelect = 198,
RULE_propertySelectionList = 199, RULE_propertySelectionListElement = 200,
RULE_propertyStreamSelector = 201, RULE_typeExpressionAnnotation = 202,
RULE_patternFilterExpression = 203, RULE_patternFilterAnnotation = 204,
RULE_classIdentifierNoDimensions = 205, RULE_classIdentifierWithDimensions = 206,
RULE_typeParameters = 207, RULE_dimensions = 208, RULE_classIdentifier = 209,
RULE_expressionListWithNamed = 210, RULE_expressionListWithNamedWithTime = 211,
RULE_expressionWithNamed = 212, RULE_expressionWithNamedWithTime = 213,
RULE_expressionNamedParameter = 214, RULE_expressionNamedParameterWithTime = 215,
RULE_expressionList = 216, RULE_expressionWithTimeList = 217, RULE_expressionWithTime = 218,
RULE_expressionWithTimeInclLast = 219, RULE_expressionQualifyable = 220,
RULE_lastWeekdayOperand = 221, RULE_lastOperand = 222, RULE_frequencyOperand = 223,
RULE_rangeOperand = 224, RULE_lastOperator = 225, RULE_weekDayOperator = 226,
RULE_numericParameterList = 227, RULE_numericListParameter = 228, RULE_chainable = 229,
RULE_chainableRootWithOpt = 230, RULE_chainableElements = 231, RULE_chainableAtomicWithOpt = 232,
RULE_chainableAtomic = 233, RULE_chainableArray = 234, RULE_chainableWithArgs = 235,
RULE_chainableIdent = 236, RULE_identOrTicked = 237, RULE_keywordAllowedIdent = 238,
RULE_escapableStr = 239, RULE_escapableIdent = 240, RULE_timePeriod = 241,
RULE_yearPart = 242, RULE_monthPart = 243, RULE_weekPart = 244, RULE_dayPart = 245,
RULE_hourPart = 246, RULE_minutePart = 247, RULE_secondPart = 248, RULE_millisecondPart = 249,
RULE_microsecondPart = 250, RULE_number = 251, RULE_substitution = 252,
RULE_substitutionSlashIdent = 253, RULE_constant = 254, RULE_numberconstant = 255,
RULE_stringconstant = 256, RULE_jsonvalue = 257, RULE_jsonobject = 258,
RULE_jsonarray = 259, RULE_jsonelements = 260, RULE_jsonmembers = 261,
RULE_jsonpair = 262;
private static String[] makeRuleNames() {
return new String[] {
"startEPLExpressionRule", "startEventPropertyRule", "startJsonValueRule",
"classDecl", "expressionDecl", "expressionDialect", "expressionDef",
"expressionLambdaDecl", "expressionTypeAnno", "annotationEnum", "elementValuePairsEnum",
"elementValuePairEnum", "elementValueEnum", "elementValueArrayEnum",
"eplExpression", "contextExpr", "selectExpr", "onExpr", "onStreamExpr",
"updateExpr", "updateDetails", "onMergeExpr", "mergeItem", "mergeMatched",
"mergeMatchedItem", "onMergeDirectInsert", "mergeUnmatched", "mergeUnmatchedItem",
"mergeInsert", "onSelectExpr", "onUpdateExpr", "onSelectInsertExpr",
"onSelectInsertFromClause", "outputClauseInsert", "onDeleteExpr", "onSetExpr",
"onSetAssignmentList", "onSetAssignment", "onExprFrom", "createWindowExpr",
"createWindowExprModelAfter", "createIndexExpr", "createIndexColumnList",
"createIndexColumn", "createVariableExpr", "createTableExpr", "createTableColumnList",
"createTableColumn", "createColumnList", "createColumnListElement", "createSelectionList",
"createSelectionListElement", "createSchemaExpr", "createSchemaDef",
"fafDelete", "fafUpdate", "fafInsert", "fafInsertRow", "createDataflow",
"gopList", "gop", "gopParams", "gopParamsItemList", "gopParamsItem",
"gopParamsItemMany", "gopParamsItemAs", "gopOut", "gopOutItem", "gopOutTypeList",
"gopOutTypeParam", "gopOutTypeItem", "gopDetail", "gopConfig", "createContextExpr",
"createExpressionExpr", "createClassExpr", "createContextDetail", "contextContextNested",
"createContextChoice", "createContextDistinct", "createContextRangePoint",
"createContextFilter", "createContextPartitionItem", "createContextCoalesceItem",
"createContextGroupItem", "createContextPartitionInit", "createContextPartitionTerm",
"createSchemaQual", "variantList", "variantListElement", "intoTableExpr",
"insertIntoExpr", "insertIntoEventPrecedence", "columnList", "columnListKeywordAllowed",
"fromClause", "regularJoin", "outerJoinList", "outerJoin", "outerJoinIdent",
"outerJoinIdentPair", "whereClause", "selectClause", "selectionList",
"selectionListElement", "selectionListElementExpr", "selectionListElementAnno",
"streamSelector", "streamExpression", "forExpr", "patternInclusionExpression",
"databaseJoinExpression", "methodJoinExpression", "viewExpressions",
"viewExpressionWNamespace", "viewExpressionOptNamespace", "viewWParameters",
"groupByListExpr", "groupByListChoice", "groupByCubeOrRollup", "groupByGroupingSets",
"groupBySetsChoice", "groupByCombinableExpr", "orderByListExpr", "orderByListElement",
"havingClause", "outputLimit", "outputLimitAndTerm", "outputLimitAfter",
"rowLimit", "crontabLimitParameterSetList", "crontabLimitParameterSet",
"whenClause", "elseClause", "matchRecog", "matchRecogPartitionBy", "matchRecogMeasures",
"matchRecogMeasureItem", "matchRecogMatchesSelection", "matchRecogPattern",
"matchRecogMatchesAfterSkip", "matchRecogMatchesInterval", "matchRecogPatternAlteration",
"matchRecogPatternConcat", "matchRecogPatternUnary", "matchRecogPatternNested",
"matchRecogPatternPermute", "matchRecogPatternAtom", "matchRecogPatternRepeat",
"matchRecogDefine", "matchRecogDefineItem", "expression", "caseExpression",
"evalOrExpression", "evalAndExpression", "bitWiseExpression", "negatedExpression",
"evalEqualsExpression", "evalRelationalExpression", "inSubSelectQuery",
"concatenationExpr", "additiveExpression", "multiplyExpression", "unaryExpression",
"unaryMinus", "substitutionCanChain", "newAssign", "rowSubSelectExpression",
"subSelectGroupExpression", "existsSubSelectExpression", "subQueryExpr",
"subSelectFilterExpr", "arrayExpression", "builtinFunc", "firstLastWindowAggregation",
"libFunctionNoClass", "funcIdentChained", "libFunctionArgs", "libFunctionArgItem",
"betweenList", "patternExpression", "followedByExpression", "followedByRepeat",
"orExpression", "andExpression", "matchUntilExpression", "qualifyExpression",
"guardPostFix", "distinctExpressionList", "distinctExpressionAtom", "atomicExpression",
"observerExpression", "guardWhereExpression", "guardWhileExpression",
"matchUntilRange", "eventFilterExpression", "propertyExpression", "propertyExpressionAtomic",
"propertyExpressionSelect", "propertySelectionList", "propertySelectionListElement",
"propertyStreamSelector", "typeExpressionAnnotation", "patternFilterExpression",
"patternFilterAnnotation", "classIdentifierNoDimensions", "classIdentifierWithDimensions",
"typeParameters", "dimensions", "classIdentifier", "expressionListWithNamed",
"expressionListWithNamedWithTime", "expressionWithNamed", "expressionWithNamedWithTime",
"expressionNamedParameter", "expressionNamedParameterWithTime", "expressionList",
"expressionWithTimeList", "expressionWithTime", "expressionWithTimeInclLast",
"expressionQualifyable", "lastWeekdayOperand", "lastOperand", "frequencyOperand",
"rangeOperand", "lastOperator", "weekDayOperator", "numericParameterList",
"numericListParameter", "chainable", "chainableRootWithOpt", "chainableElements",
"chainableAtomicWithOpt", "chainableAtomic", "chainableArray", "chainableWithArgs",
"chainableIdent", "identOrTicked", "keywordAllowedIdent", "escapableStr",
"escapableIdent", "timePeriod", "yearPart", "monthPart", "weekPart",
"dayPart", "hourPart", "minutePart", "secondPart", "millisecondPart",
"microsecondPart", "number", "substitution", "substitutionSlashIdent",
"constant", "numberconstant", "stringconstant", "jsonvalue", "jsonobject",
"jsonarray", "jsonelements", "jsonmembers", "jsonpair"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'create'", "'window'", "'in'", "'between'", "'like'", "'regexp'",
"'escape'", "'or'", "'and'", "'not'", "'every'", "'every-distinct'",
"'where'", "'as'", "'sum'", "'avg'", "'max'", "'min'", "'coalesce'",
"'median'", "'stddev'", "'avedev'", "'count'", "'select'", "'case'",
"'else'", "'when'", "'then'", "'end'", "'from'", "'outer'", "'inner'",
"'join'", "'left'", "'right'", "'full'", "'on'", "'is'", "'by'", "'group'",
"'having'", "'distinct'", "'all'", "'any'", "'some'", "'output'", "'events'",
"'first'", "'last'", "'insert'", "'into'", "'values'", "'order'", "'asc'",
"'desc'", "'rstream'", "'istream'", "'irstream'", "'schema'", "'unidirectional'",
"'retain-union'", "'retain-intersection'", "'pattern'", "'sql'", "'metadatasql'",
"'prev'", "'prevtail'", "'prevcount'", "'prevwindow'", "'prior'", "'exists'",
"'weekday'", "'lastweekday'", "'instanceof'", "'typeof'", "'cast'", "'current_timestamp'",
"'delete'", "'snapshot'", "'set'", "'variable'", "'table'", "'until'",
"'at'", "'index'", "'year'", "'years'", "'month'", "'months'", "'week'",
"'weeks'", "'day'", "'days'", "'hour'", "'hours'", "'minute'", "'minutes'",
"'sec'", "'second'", "'seconds'", "'msec'", "'millisecond'", "'milliseconds'",
"'usec'", "'microsecond'", "'microseconds'", "'true'", "'false'", "'null'",
"'limit'", "'offset'", "'update'", "'match_recognize'", "'match_recognize_permute'",
"'measures'", "'define'", "'partition'", "'matches'", "'after'", "'for'",
"'while'", "'using'", "'merge'", "'matched'", "'expression'", "'inlined_class'",
"'new'", "'start'", "'context'", "'initiated'", "'terminated'", "'dataflow'",
"'cube'", "'rollup'", "'grouping'", "'grouping_id'", "'sets'", "'event-precedence'",
"'-['", "'->'", "'=>'", "'='", "'<>'", "'?'", "'('", "')'", "'['", "']'",
"'{'", "'}'", "':'", "','", "'=='", "'!'", "'~'", "'!='", "'/'", "'/='",
"'+'", "'+='", "'++'", "'-'", "'-='", "'--'", "'*'", "'*='", "'%'", "'%='",
"'>='", "'>'", "'<='", "'<'", "'^'", "'^='", "'|'", "'|='", "'||'", "'&'",
"'&='", "'&&'", "';'", "'.'", "'\u18FF'", "'\u18FE'", "'\u18FD'", "'\\'",
"'`'", "'@'", "'#'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "CREATE", "WINDOW", "IN_SET", "BETWEEN", "LIKE", "REGEXP", "ESCAPE",
"OR_EXPR", "AND_EXPR", "NOT_EXPR", "EVERY_EXPR", "EVERY_DISTINCT_EXPR",
"WHERE", "AS", "SUM", "AVG", "MAX", "MIN", "COALESCE", "MEDIAN", "STDDEV",
"AVEDEV", "COUNT", "SELECT", "CASE", "ELSE", "WHEN", "THEN", "END", "FROM",
"OUTER", "INNER", "JOIN", "LEFT", "RIGHT", "FULL", "ON", "IS", "BY",
"GROUP", "HAVING", "DISTINCT", "ALL", "ANY", "SOME", "OUTPUT", "EVENTS",
"FIRST", "LAST", "INSERT", "INTO", "VALUES", "ORDER", "ASC", "DESC",
"RSTREAM", "ISTREAM", "IRSTREAM", "SCHEMA", "UNIDIRECTIONAL", "RETAINUNION",
"RETAININTERSECTION", "PATTERN", "SQL", "METADATASQL", "PREVIOUS", "PREVIOUSTAIL",
"PREVIOUSCOUNT", "PREVIOUSWINDOW", "PRIOR", "EXISTS", "WEEKDAY", "LW",
"INSTANCEOF", "TYPEOF", "CAST", "CURRENT_TIMESTAMP", "DELETE", "SNAPSHOT",
"SET", "VARIABLE", "TABLE", "UNTIL", "AT", "INDEX", "TIMEPERIOD_YEAR",
"TIMEPERIOD_YEARS", "TIMEPERIOD_MONTH", "TIMEPERIOD_MONTHS", "TIMEPERIOD_WEEK",
"TIMEPERIOD_WEEKS", "TIMEPERIOD_DAY", "TIMEPERIOD_DAYS", "TIMEPERIOD_HOUR",
"TIMEPERIOD_HOURS", "TIMEPERIOD_MINUTE", "TIMEPERIOD_MINUTES", "TIMEPERIOD_SEC",
"TIMEPERIOD_SECOND", "TIMEPERIOD_SECONDS", "TIMEPERIOD_MILLISEC", "TIMEPERIOD_MILLISECOND",
"TIMEPERIOD_MILLISECONDS", "TIMEPERIOD_MICROSEC", "TIMEPERIOD_MICROSECOND",
"TIMEPERIOD_MICROSECONDS", "BOOLEAN_TRUE", "BOOLEAN_FALSE", "VALUE_NULL",
"ROW_LIMIT_EXPR", "OFFSET", "UPDATE", "MATCH_RECOGNIZE", "MATCH_RECOGNIZE_PERMUTE",
"MEASURES", "DEFINE", "PARTITION", "MATCHES", "AFTER", "FOR", "WHILE",
"USING", "MERGE", "MATCHED", "EXPRESSIONDECL", "CLASSDECL", "NEWKW",
"START", "CONTEXT", "INITIATED", "TERMINATED", "DATAFLOW", "CUBE", "ROLLUP",
"GROUPING", "GROUPING_ID", "SETS", "EVENTPRECEDENCE", "FOLLOWMAX_BEGIN",
"FOLLOWED_BY", "GOES", "EQUALS", "SQL_NE", "QUESTION", "LPAREN", "RPAREN",
"LBRACK", "RBRACK", "LCURLY", "RCURLY", "COLON", "COMMA", "EQUAL", "LNOT",
"BNOT", "NOT_EQUAL", "DIV", "DIV_ASSIGN", "PLUS", "PLUS_ASSIGN", "INC",
"MINUS", "MINUS_ASSIGN", "DEC", "STAR", "STAR_ASSIGN", "MOD", "MOD_ASSIGN",
"GE", "GT", "LE", "LT", "BXOR", "BXOR_ASSIGN", "BOR", "BOR_ASSIGN", "LOR",
"BAND", "BAND_ASSIGN", "LAND", "SEMI", "DOT", "NUM_LONG", "NUM_DOUBLE",
"NUM_FLOAT", "ESCAPECHAR", "ESCAPEBACKTICK", "ATCHAR", "HASHCHAR", "WS",
"SL_COMMENT", "ML_COMMENT", "TICKED_STRING_LITERAL", "QUOTED_STRING_LITERAL",
"STRING_LITERAL", "TRIPLEQUOTE", "IDENT", "IntegerLiteral", "FloatingPointLiteral"
};
}
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 "EsperEPL2Grammar.g"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
// provide nice error messages
private java.util.Stack paraphrases = new java.util.Stack();
// static information initialized once
private static java.util.Map lexerTokenParaphases = new java.util.HashMap();
private static java.util.Map parserTokenParaphases = new java.util.HashMap();
private static java.util.Set parserKeywordSet = new java.util.HashSet();
private static java.util.Set afterScriptTokens = new java.util.HashSet();
public java.util.Stack getParaphrases() {
return paraphrases;
}
public java.util.Set getKeywords() {
getParserTokenParaphrases();
return parserKeywordSet;
}
public synchronized static java.util.Map getLexerTokenParaphrases() {
if (lexerTokenParaphases.size() == 0) {
lexerTokenParaphases.put(IDENT, "an identifier");
lexerTokenParaphases.put(FOLLOWED_BY, "an followed-by '->'");
lexerTokenParaphases.put(EQUALS, "an equals '='");
lexerTokenParaphases.put(SQL_NE, "a sql-style not equals '<>'");
lexerTokenParaphases.put(QUESTION, "a questionmark '?'");
lexerTokenParaphases.put(LPAREN, "an opening parenthesis '('");
lexerTokenParaphases.put(RPAREN, "a closing parenthesis ')'");
lexerTokenParaphases.put(LBRACK, "a left angle bracket '['");
lexerTokenParaphases.put(RBRACK, "a right angle bracket ']'");
lexerTokenParaphases.put(LCURLY, "a left curly bracket '{'");
lexerTokenParaphases.put(RCURLY, "a right curly bracket '}'");
lexerTokenParaphases.put(COLON, "a colon ':'");
lexerTokenParaphases.put(COMMA, "a comma ','");
lexerTokenParaphases.put(EQUAL, "an equals compare '=='");
lexerTokenParaphases.put(LNOT, "a not '!'");
lexerTokenParaphases.put(BNOT, "a binary not '~'");
lexerTokenParaphases.put(NOT_EQUAL, "a not equals '!='");
lexerTokenParaphases.put(DIV, "a division operator '\'");
lexerTokenParaphases.put(DIV_ASSIGN, "a division assign '/='");
lexerTokenParaphases.put(PLUS, "a plus operator '+'");
lexerTokenParaphases.put(PLUS_ASSIGN, "a plus assign '+='");
lexerTokenParaphases.put(INC, "an increment operator '++'");
lexerTokenParaphases.put(MINUS, "a minus '-'");
lexerTokenParaphases.put(MINUS_ASSIGN, "a minus assign '-='");
lexerTokenParaphases.put(DEC, "a decrement operator '--'");
lexerTokenParaphases.put(STAR, "a star '*'");
lexerTokenParaphases.put(STAR_ASSIGN, "a star assign '*='");
lexerTokenParaphases.put(MOD, "a modulo");
lexerTokenParaphases.put(MOD_ASSIGN, "a modulo assign");
lexerTokenParaphases.put(GE, "a greater equals '>='");
lexerTokenParaphases.put(GT, "a greater then '>'");
lexerTokenParaphases.put(LE, "a less equals '<='");
lexerTokenParaphases.put(LT, "a lesser then '<'");
lexerTokenParaphases.put(BXOR, "a binary xor '^'");
lexerTokenParaphases.put(BXOR_ASSIGN, "a binary xor assign '^='");
lexerTokenParaphases.put(BOR, "a binary or '|'");
lexerTokenParaphases.put(BOR_ASSIGN, "a binary or assign '|='");
lexerTokenParaphases.put(LOR, "a logical or '||'");
lexerTokenParaphases.put(BAND, "a binary and '&'");
lexerTokenParaphases.put(BAND_ASSIGN, "a binary and assign '&='");
lexerTokenParaphases.put(LAND, "a logical and '&&'");
lexerTokenParaphases.put(SEMI, "a semicolon ';'");
lexerTokenParaphases.put(DOT, "a dot '.'");
}
return lexerTokenParaphases;
}
public synchronized static java.util.Map getParserTokenParaphrases() {
if (parserTokenParaphases.size() == 0) {
parserTokenParaphases.put(CREATE, "'create'");
parserTokenParaphases.put(WINDOW, "'window'");
parserTokenParaphases.put(IN_SET, "'in'");
parserTokenParaphases.put(BETWEEN, "'between'");
parserTokenParaphases.put(LIKE, "'like'");
parserTokenParaphases.put(REGEXP, "'regexp'");
parserTokenParaphases.put(ESCAPE, "'escape'");
parserTokenParaphases.put(OR_EXPR, "'or'");
parserTokenParaphases.put(AND_EXPR, "'and'");
parserTokenParaphases.put(NOT_EXPR, "'not'");
parserTokenParaphases.put(EVERY_EXPR, "'every'");
parserTokenParaphases.put(EVERY_DISTINCT_EXPR, "'every-distinct'");
parserTokenParaphases.put(WHERE, "'where'");
parserTokenParaphases.put(AS, "'as'");
parserTokenParaphases.put(SUM, "'sum'");
parserTokenParaphases.put(AVG, "'avg'");
parserTokenParaphases.put(MAX, "'max'");
parserTokenParaphases.put(MIN, "'min'");
parserTokenParaphases.put(COALESCE, "'coalesce'");
parserTokenParaphases.put(MEDIAN, "'median'");
parserTokenParaphases.put(STDDEV, "'stddev'");
parserTokenParaphases.put(AVEDEV, "'avedev'");
parserTokenParaphases.put(COUNT, "'count'");
parserTokenParaphases.put(SELECT, "'select'");
parserTokenParaphases.put(CASE, "'case'");
parserTokenParaphases.put(ELSE, "'else'");
parserTokenParaphases.put(WHEN, "'when'");
parserTokenParaphases.put(THEN, "'then'");
parserTokenParaphases.put(END, "'end'");
parserTokenParaphases.put(FROM, "'from'");
parserTokenParaphases.put(OUTER, "'outer'");
parserTokenParaphases.put(INNER, "'inner'");
parserTokenParaphases.put(JOIN, "'join'");
parserTokenParaphases.put(LEFT, "'left'");
parserTokenParaphases.put(RIGHT, "'right'");
parserTokenParaphases.put(FULL, "'full'");
parserTokenParaphases.put(ON, "'on'");
parserTokenParaphases.put(IS, "'is'");
parserTokenParaphases.put(BY, "'by'");
parserTokenParaphases.put(GROUP, "'group'");
parserTokenParaphases.put(HAVING, "'having'");
parserTokenParaphases.put(ALL, "'all'");
parserTokenParaphases.put(ANY, "'any'");
parserTokenParaphases.put(SOME, "'some'");
parserTokenParaphases.put(OUTPUT, "'output'");
parserTokenParaphases.put(EVENTS, "'events'");
parserTokenParaphases.put(FIRST, "'first'");
parserTokenParaphases.put(LAST, "'last'");
parserTokenParaphases.put(INSERT, "'insert'");
parserTokenParaphases.put(INTO, "'into'");
parserTokenParaphases.put(ORDER, "'order'");
parserTokenParaphases.put(ASC, "'asc'");
parserTokenParaphases.put(DESC, "'desc'");
parserTokenParaphases.put(RSTREAM, "'rstream'");
parserTokenParaphases.put(ISTREAM, "'istream'");
parserTokenParaphases.put(IRSTREAM, "'irstream'");
parserTokenParaphases.put(SCHEMA, "'schema'");
parserTokenParaphases.put(UNIDIRECTIONAL, "'unidirectional'");
parserTokenParaphases.put(RETAINUNION, "'retain-union'");
parserTokenParaphases.put(RETAININTERSECTION, "'retain-intersection'");
parserTokenParaphases.put(PATTERN, "'pattern'");
parserTokenParaphases.put(SQL, "'sql'");
parserTokenParaphases.put(METADATASQL, "'metadatasql'");
parserTokenParaphases.put(PREVIOUS, "'prev'");
parserTokenParaphases.put(PREVIOUSTAIL, "'prevtail'");
parserTokenParaphases.put(PREVIOUSCOUNT, "'prevcount'");
parserTokenParaphases.put(PREVIOUSWINDOW, "'prevwindow'");
parserTokenParaphases.put(PRIOR, "'prior'");
parserTokenParaphases.put(EXISTS, "'exists'");
parserTokenParaphases.put(WEEKDAY, "'weekday'");
parserTokenParaphases.put(LW, "'lastweekday'");
parserTokenParaphases.put(INSTANCEOF, "'instanceof'");
parserTokenParaphases.put(TYPEOF, "'typeof'");
parserTokenParaphases.put(CAST, "'cast'");
parserTokenParaphases.put(CURRENT_TIMESTAMP, "'current_timestamp'");
parserTokenParaphases.put(DELETE, "'delete'");
parserTokenParaphases.put(DISTINCT, "'distinct'");
parserTokenParaphases.put(SNAPSHOT, "'snapshot'");
parserTokenParaphases.put(SET, "'set'");
parserTokenParaphases.put(VARIABLE, "'variable'");
parserTokenParaphases.put(TABLE, "'table'");
parserTokenParaphases.put(INDEX, "'index'");
parserTokenParaphases.put(UNTIL, "'until'");
parserTokenParaphases.put(AT, "'at'");
parserTokenParaphases.put(TIMEPERIOD_YEAR, "'year'");
parserTokenParaphases.put(TIMEPERIOD_YEARS, "'years'");
parserTokenParaphases.put(TIMEPERIOD_MONTH, "'month'");
parserTokenParaphases.put(TIMEPERIOD_MONTHS, "'months'");
parserTokenParaphases.put(TIMEPERIOD_WEEK, "'week'");
parserTokenParaphases.put(TIMEPERIOD_WEEKS, "'weeks'");
parserTokenParaphases.put(TIMEPERIOD_DAY, "'day'");
parserTokenParaphases.put(TIMEPERIOD_DAYS, "'days'");
parserTokenParaphases.put(TIMEPERIOD_HOUR, "'hour'");
parserTokenParaphases.put(TIMEPERIOD_HOURS, "'hours'");
parserTokenParaphases.put(TIMEPERIOD_MINUTE, "'minute'");
parserTokenParaphases.put(TIMEPERIOD_MINUTES, "'minutes'");
parserTokenParaphases.put(TIMEPERIOD_SEC, "'sec'");
parserTokenParaphases.put(TIMEPERIOD_SECOND, "'second'");
parserTokenParaphases.put(TIMEPERIOD_SECONDS, "'seconds'");
parserTokenParaphases.put(TIMEPERIOD_MILLISEC, "'msec'");
parserTokenParaphases.put(TIMEPERIOD_MILLISECOND, "'millisecond'");
parserTokenParaphases.put(TIMEPERIOD_MILLISECONDS, "'milliseconds'");
parserTokenParaphases.put(TIMEPERIOD_MICROSEC, "'usec'");
parserTokenParaphases.put(TIMEPERIOD_MICROSECOND, "'microsecond'");
parserTokenParaphases.put(TIMEPERIOD_MICROSECONDS, "'microseconds'");
parserTokenParaphases.put(BOOLEAN_TRUE, "'true'");
parserTokenParaphases.put(BOOLEAN_FALSE, "'false'");
parserTokenParaphases.put(VALUE_NULL, "'null'");
parserTokenParaphases.put(ROW_LIMIT_EXPR, "'limit'");
parserTokenParaphases.put(OFFSET, "'offset'");
parserTokenParaphases.put(UPDATE, "'update'");
parserTokenParaphases.put(MATCH_RECOGNIZE, "'match_recognize'");
parserTokenParaphases.put(MEASURES, "'measures'");
parserTokenParaphases.put(DEFINE, "'define'");
parserTokenParaphases.put(PARTITION, "'partition'");
parserTokenParaphases.put(MATCHES, "'matches'");
parserTokenParaphases.put(AFTER, "'after'");
parserTokenParaphases.put(FOR, "'for'");
parserTokenParaphases.put(WHILE, "'while'");
parserTokenParaphases.put(MERGE, "'merge'");
parserTokenParaphases.put(MATCHED, "'matched'");
parserTokenParaphases.put(CONTEXT, "'context'");
parserTokenParaphases.put(START, "'start'");
parserTokenParaphases.put(END, "'end'");
parserTokenParaphases.put(INITIATED, "'initiated'");
parserTokenParaphases.put(TERMINATED, "'terminated'");
parserTokenParaphases.put(USING, "'using'");
parserTokenParaphases.put(EXPRESSIONDECL, "'expression'");
parserTokenParaphases.put(CLASSDECL, "'inlined_class'");
parserTokenParaphases.put(NEWKW, "'new'");
parserTokenParaphases.put(DATAFLOW, "'dataflow'");
parserTokenParaphases.put(VALUES, "'values'");
parserTokenParaphases.put(CUBE, "'cube'");
parserTokenParaphases.put(ROLLUP, "'rollup'");
parserTokenParaphases.put(GROUPING, "'grouping'");
parserTokenParaphases.put(GROUPING_ID, "'grouping_id'");
parserTokenParaphases.put(SETS, "'sets'");
parserTokenParaphases.put(EVENTPRECEDENCE, "'event-precedence'");
parserKeywordSet = new java.util.TreeSet(parserTokenParaphases.values());
}
return parserTokenParaphases;
}
public synchronized static java.util.Set getAfterScriptTokens() {
if (afterScriptTokens.size() == 0) {
afterScriptTokens.add(CREATE);
afterScriptTokens.add(EXPRESSIONDECL);
afterScriptTokens.add(SELECT);
afterScriptTokens.add(INSERT);
afterScriptTokens.add(ON);
afterScriptTokens.add(DELETE);
afterScriptTokens.add(UPDATE);
afterScriptTokens.add(ATCHAR);
}
return afterScriptTokens;
}
public EsperEPL2GrammarParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class StartEPLExpressionRuleContext extends ParserRuleContext {
public EplExpressionContext eplExpression() {
return getRuleContext(EplExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public List expressionDecl() {
return getRuleContexts(ExpressionDeclContext.class);
}
public ExpressionDeclContext expressionDecl(int i) {
return getRuleContext(ExpressionDeclContext.class,i);
}
public List classDecl() {
return getRuleContexts(ClassDeclContext.class);
}
public ClassDeclContext classDecl(int i) {
return getRuleContext(ClassDeclContext.class,i);
}
public StartEPLExpressionRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startEPLExpressionRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStartEPLExpressionRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStartEPLExpressionRule(this);
}
}
public final StartEPLExpressionRuleContext startEPLExpressionRule() throws RecognitionException {
StartEPLExpressionRuleContext _localctx = new StartEPLExpressionRuleContext(_ctx, getState());
enterRule(_localctx, 0, RULE_startEPLExpressionRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(531);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (EXPRESSIONDECL - 125)) | (1L << (CLASSDECL - 125)) | (1L << (ATCHAR - 125)))) != 0)) {
{
setState(529);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(526);
annotationEnum();
}
break;
case EXPRESSIONDECL:
{
setState(527);
expressionDecl();
}
break;
case CLASSDECL:
{
setState(528);
classDecl();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(533);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(534);
eplExpression();
setState(535);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StartEventPropertyRuleContext extends ParserRuleContext {
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public StartEventPropertyRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startEventPropertyRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStartEventPropertyRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStartEventPropertyRule(this);
}
}
public final StartEventPropertyRuleContext startEventPropertyRule() throws RecognitionException {
StartEventPropertyRuleContext _localctx = new StartEventPropertyRuleContext(_ctx, getState());
enterRule(_localctx, 2, RULE_startEventPropertyRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(537);
chainable();
setState(538);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StartJsonValueRuleContext extends ParserRuleContext {
public JsonvalueContext jsonvalue() {
return getRuleContext(JsonvalueContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public StartJsonValueRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startJsonValueRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStartJsonValueRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStartJsonValueRule(this);
}
}
public final StartJsonValueRuleContext startJsonValueRule() throws RecognitionException {
StartJsonValueRuleContext _localctx = new StartJsonValueRuleContext(_ctx, getState());
enterRule(_localctx, 4, RULE_startJsonValueRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(540);
jsonvalue();
setState(541);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassDeclContext extends ParserRuleContext {
public TerminalNode CLASSDECL() { return getToken(EsperEPL2GrammarParser.CLASSDECL, 0); }
public List TRIPLEQUOTE() { return getTokens(EsperEPL2GrammarParser.TRIPLEQUOTE); }
public TerminalNode TRIPLEQUOTE(int i) {
return getToken(EsperEPL2GrammarParser.TRIPLEQUOTE, i);
}
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public ClassDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterClassDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitClassDecl(this);
}
}
public final ClassDeclContext classDecl() throws RecognitionException {
ClassDeclContext _localctx = new ClassDeclContext(_ctx, getState());
enterRule(_localctx, 6, RULE_classDecl);
try {
enterOuterAlt(_localctx, 1);
{
setState(543);
match(CLASSDECL);
setState(544);
match(TRIPLEQUOTE);
setState(545);
stringconstant();
setState(546);
match(TRIPLEQUOTE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionDeclContext extends ParserRuleContext {
public Token name;
public Token alias;
public TerminalNode EXPRESSIONDECL() { return getToken(EsperEPL2GrammarParser.EXPRESSIONDECL, 0); }
public ExpressionDefContext expressionDef() {
return getRuleContext(ExpressionDefContext.class,0);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public TypeExpressionAnnotationContext typeExpressionAnnotation() {
return getRuleContext(TypeExpressionAnnotationContext.class,0);
}
public ExpressionDialectContext expressionDialect() {
return getRuleContext(ExpressionDialectContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode FOR() { return getToken(EsperEPL2GrammarParser.FOR, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public ExpressionDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionDecl(this);
}
}
public final ExpressionDeclContext expressionDecl() throws RecognitionException {
ExpressionDeclContext _localctx = new ExpressionDeclContext(_ctx, getState());
enterRule(_localctx, 8, RULE_expressionDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(548);
match(EXPRESSIONDECL);
setState(550);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(549);
classIdentifierWithDimensions();
}
break;
}
setState(553);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(552);
typeExpressionAnnotation();
}
}
setState(556);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(555);
expressionDialect();
}
break;
}
setState(558);
((ExpressionDeclContext)_localctx).name = match(IDENT);
setState(564);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(559);
match(LPAREN);
setState(561);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(560);
columnList();
}
}
setState(563);
match(RPAREN);
}
}
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(566);
((ExpressionDeclContext)_localctx).alias = match(IDENT);
setState(567);
match(FOR);
}
}
setState(570);
expressionDef();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionDialectContext extends ParserRuleContext {
public Token d;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ExpressionDialectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionDialect; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionDialect(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionDialect(this);
}
}
public final ExpressionDialectContext expressionDialect() throws RecognitionException {
ExpressionDialectContext _localctx = new ExpressionDialectContext(_ctx, getState());
enterRule(_localctx, 10, RULE_expressionDialect);
try {
enterOuterAlt(_localctx, 1);
{
setState(572);
((ExpressionDialectContext)_localctx).d = match(IDENT);
setState(573);
match(COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionDefContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public ExpressionLambdaDeclContext expressionLambdaDecl() {
return getRuleContext(ExpressionLambdaDeclContext.class,0);
}
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public ExpressionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionDef(this);
}
}
public final ExpressionDefContext expressionDef() throws RecognitionException {
ExpressionDefContext _localctx = new ExpressionDefContext(_ctx, getState());
enterRule(_localctx, 12, RULE_expressionDef);
try {
setState(586);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURLY:
enterOuterAlt(_localctx, 1);
{
setState(575);
match(LCURLY);
setState(577);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(576);
expressionLambdaDecl();
}
break;
}
setState(579);
expression();
setState(580);
match(RCURLY);
}
break;
case LBRACK:
enterOuterAlt(_localctx, 2);
{
setState(582);
match(LBRACK);
setState(583);
stringconstant();
setState(584);
match(RBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionLambdaDeclContext extends ParserRuleContext {
public KeywordAllowedIdentContext i;
public TerminalNode GOES() { return getToken(EsperEPL2GrammarParser.GOES, 0); }
public TerminalNode FOLLOWED_BY() { return getToken(EsperEPL2GrammarParser.FOLLOWED_BY, 0); }
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ColumnListKeywordAllowedContext columnListKeywordAllowed() {
return getRuleContext(ColumnListKeywordAllowedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionLambdaDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionLambdaDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionLambdaDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionLambdaDecl(this);
}
}
public final ExpressionLambdaDeclContext expressionLambdaDecl() throws RecognitionException {
ExpressionLambdaDeclContext _localctx = new ExpressionLambdaDeclContext(_ctx, getState());
enterRule(_localctx, 14, RULE_expressionLambdaDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(593);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WINDOW:
case BETWEEN:
case ESCAPE:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PRIOR:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case CONTEXT:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(588);
((ExpressionLambdaDeclContext)_localctx).i = keywordAllowedIdent();
}
break;
case LPAREN:
{
{
setState(589);
match(LPAREN);
setState(590);
columnListKeywordAllowed();
setState(591);
match(RPAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(595);
_la = _input.LA(1);
if ( !(_la==FOLLOWED_BY || _la==GOES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionTypeAnnoContext extends ParserRuleContext {
public Token n;
public Token v;
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionTypeAnnoContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionTypeAnno; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionTypeAnno(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionTypeAnno(this);
}
}
public final ExpressionTypeAnnoContext expressionTypeAnno() throws RecognitionException {
ExpressionTypeAnnoContext _localctx = new ExpressionTypeAnnoContext(_ctx, getState());
enterRule(_localctx, 16, RULE_expressionTypeAnno);
try {
enterOuterAlt(_localctx, 1);
{
setState(597);
match(ATCHAR);
setState(598);
((ExpressionTypeAnnoContext)_localctx).n = match(IDENT);
{
setState(599);
match(LPAREN);
setState(600);
((ExpressionTypeAnnoContext)_localctx).v = match(IDENT);
setState(601);
match(RPAREN);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationEnumContext extends ParserRuleContext {
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ElementValuePairsEnumContext elementValuePairsEnum() {
return getRuleContext(ElementValuePairsEnumContext.class,0);
}
public ElementValueEnumContext elementValueEnum() {
return getRuleContext(ElementValueEnumContext.class,0);
}
public AnnotationEnumContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationEnum; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterAnnotationEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitAnnotationEnum(this);
}
}
public final AnnotationEnumContext annotationEnum() throws RecognitionException {
AnnotationEnumContext _localctx = new AnnotationEnumContext(_ctx, getState());
enterRule(_localctx, 18, RULE_annotationEnum);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(603);
match(ATCHAR);
setState(604);
classIdentifier();
setState(611);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(605);
match(LPAREN);
setState(608);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(606);
elementValuePairsEnum();
}
break;
case 2:
{
setState(607);
elementValueEnum();
}
break;
}
setState(610);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairsEnumContext extends ParserRuleContext {
public List elementValuePairEnum() {
return getRuleContexts(ElementValuePairEnumContext.class);
}
public ElementValuePairEnumContext elementValuePairEnum(int i) {
return getRuleContext(ElementValuePairEnumContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ElementValuePairsEnumContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePairsEnum; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterElementValuePairsEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitElementValuePairsEnum(this);
}
}
public final ElementValuePairsEnumContext elementValuePairsEnum() throws RecognitionException {
ElementValuePairsEnumContext _localctx = new ElementValuePairsEnumContext(_ctx, getState());
enterRule(_localctx, 20, RULE_elementValuePairsEnum);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(613);
elementValuePairEnum();
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(614);
match(COMMA);
setState(615);
elementValuePairEnum();
}
}
setState(620);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairEnumContext extends ParserRuleContext {
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public ElementValueEnumContext elementValueEnum() {
return getRuleContext(ElementValueEnumContext.class,0);
}
public ElementValuePairEnumContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePairEnum; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterElementValuePairEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitElementValuePairEnum(this);
}
}
public final ElementValuePairEnumContext elementValuePairEnum() throws RecognitionException {
ElementValuePairEnumContext _localctx = new ElementValuePairEnumContext(_ctx, getState());
enterRule(_localctx, 22, RULE_elementValuePairEnum);
try {
enterOuterAlt(_localctx, 1);
{
setState(621);
keywordAllowedIdent();
setState(622);
match(EQUALS);
setState(623);
elementValueEnum();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueEnumContext extends ParserRuleContext {
public Token v;
public AnnotationEnumContext annotationEnum() {
return getRuleContext(AnnotationEnumContext.class,0);
}
public ElementValueArrayEnumContext elementValueArrayEnum() {
return getRuleContext(ElementValueArrayEnumContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public ElementValueEnumContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValueEnum; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterElementValueEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitElementValueEnum(this);
}
}
public final ElementValueEnumContext elementValueEnum() throws RecognitionException {
ElementValueEnumContext _localctx = new ElementValueEnumContext(_ctx, getState());
enterRule(_localctx, 24, RULE_elementValueEnum);
try {
setState(630);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(625);
annotationEnum();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(626);
elementValueArrayEnum();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(627);
constant();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(628);
((ElementValueEnumContext)_localctx).v = match(IDENT);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(629);
classIdentifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueArrayEnumContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List elementValueEnum() {
return getRuleContexts(ElementValueEnumContext.class);
}
public ElementValueEnumContext elementValueEnum(int i) {
return getRuleContext(ElementValueEnumContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ElementValueArrayEnumContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValueArrayEnum; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterElementValueArrayEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitElementValueArrayEnum(this);
}
}
public final ElementValueArrayEnumContext elementValueArrayEnum() throws RecognitionException {
ElementValueArrayEnumContext _localctx = new ElementValueArrayEnumContext(_ctx, getState());
enterRule(_localctx, 26, RULE_elementValueArrayEnum);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(632);
match(LCURLY);
setState(641);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << (EVENTS - 47)) | (1L << (BOOLEAN_TRUE - 47)) | (1L << (BOOLEAN_FALSE - 47)) | (1L << (VALUE_NULL - 47)))) != 0) || ((((_la - 149)) & ~0x3f) == 0 && ((1L << (_la - 149)) & ((1L << (LCURLY - 149)) | (1L << (PLUS - 149)) | (1L << (MINUS - 149)) | (1L << (ATCHAR - 149)) | (1L << (TICKED_STRING_LITERAL - 149)) | (1L << (QUOTED_STRING_LITERAL - 149)) | (1L << (STRING_LITERAL - 149)) | (1L << (IDENT - 149)) | (1L << (IntegerLiteral - 149)) | (1L << (FloatingPointLiteral - 149)))) != 0)) {
{
setState(633);
elementValueEnum();
setState(638);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(634);
match(COMMA);
setState(635);
elementValueEnum();
}
}
}
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
}
}
}
setState(644);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(643);
match(COMMA);
}
}
setState(646);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EplExpressionContext extends ParserRuleContext {
public SelectExprContext selectExpr() {
return getRuleContext(SelectExprContext.class,0);
}
public CreateWindowExprContext createWindowExpr() {
return getRuleContext(CreateWindowExprContext.class,0);
}
public CreateIndexExprContext createIndexExpr() {
return getRuleContext(CreateIndexExprContext.class,0);
}
public CreateVariableExprContext createVariableExpr() {
return getRuleContext(CreateVariableExprContext.class,0);
}
public CreateTableExprContext createTableExpr() {
return getRuleContext(CreateTableExprContext.class,0);
}
public CreateSchemaExprContext createSchemaExpr() {
return getRuleContext(CreateSchemaExprContext.class,0);
}
public CreateContextExprContext createContextExpr() {
return getRuleContext(CreateContextExprContext.class,0);
}
public CreateExpressionExprContext createExpressionExpr() {
return getRuleContext(CreateExpressionExprContext.class,0);
}
public CreateClassExprContext createClassExpr() {
return getRuleContext(CreateClassExprContext.class,0);
}
public OnExprContext onExpr() {
return getRuleContext(OnExprContext.class,0);
}
public UpdateExprContext updateExpr() {
return getRuleContext(UpdateExprContext.class,0);
}
public CreateDataflowContext createDataflow() {
return getRuleContext(CreateDataflowContext.class,0);
}
public FafDeleteContext fafDelete() {
return getRuleContext(FafDeleteContext.class,0);
}
public FafUpdateContext fafUpdate() {
return getRuleContext(FafUpdateContext.class,0);
}
public FafInsertContext fafInsert() {
return getRuleContext(FafInsertContext.class,0);
}
public ContextExprContext contextExpr() {
return getRuleContext(ContextExprContext.class,0);
}
public ForExprContext forExpr() {
return getRuleContext(ForExprContext.class,0);
}
public EplExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eplExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEplExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEplExpression(this);
}
}
public final EplExpressionContext eplExpression() throws RecognitionException {
EplExpressionContext _localctx = new EplExpressionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_eplExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(649);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONTEXT) {
{
setState(648);
contextExpr();
}
}
setState(666);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(651);
selectExpr();
}
break;
case 2:
{
setState(652);
createWindowExpr();
}
break;
case 3:
{
setState(653);
createIndexExpr();
}
break;
case 4:
{
setState(654);
createVariableExpr();
}
break;
case 5:
{
setState(655);
createTableExpr();
}
break;
case 6:
{
setState(656);
createSchemaExpr();
}
break;
case 7:
{
setState(657);
createContextExpr();
}
break;
case 8:
{
setState(658);
createExpressionExpr();
}
break;
case 9:
{
setState(659);
createClassExpr();
}
break;
case 10:
{
setState(660);
onExpr();
}
break;
case 11:
{
setState(661);
updateExpr();
}
break;
case 12:
{
setState(662);
createDataflow();
}
break;
case 13:
{
setState(663);
fafDelete();
}
break;
case 14:
{
setState(664);
fafUpdate();
}
break;
case 15:
{
setState(665);
fafInsert();
}
break;
}
setState(669);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(668);
forExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContextExprContext extends ParserRuleContext {
public Token i;
public TerminalNode CONTEXT() { return getToken(EsperEPL2GrammarParser.CONTEXT, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ContextExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contextExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterContextExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitContextExpr(this);
}
}
public final ContextExprContext contextExpr() throws RecognitionException {
ContextExprContext _localctx = new ContextExprContext(_ctx, getState());
enterRule(_localctx, 30, RULE_contextExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(671);
match(CONTEXT);
setState(672);
((ContextExprContext)_localctx).i = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectExprContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public IntoTableExprContext intoTableExpr() {
return getRuleContext(IntoTableExprContext.class,0);
}
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public InsertIntoExprContext insertIntoExpr() {
return getRuleContext(InsertIntoExprContext.class,0);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public MatchRecogContext matchRecog() {
return getRuleContext(MatchRecogContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode GROUP() { return getToken(EsperEPL2GrammarParser.GROUP, 0); }
public List BY() { return getTokens(EsperEPL2GrammarParser.BY); }
public TerminalNode BY(int i) {
return getToken(EsperEPL2GrammarParser.BY, i);
}
public GroupByListExprContext groupByListExpr() {
return getRuleContext(GroupByListExprContext.class,0);
}
public TerminalNode HAVING() { return getToken(EsperEPL2GrammarParser.HAVING, 0); }
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public TerminalNode OUTPUT() { return getToken(EsperEPL2GrammarParser.OUTPUT, 0); }
public OutputLimitContext outputLimit() {
return getRuleContext(OutputLimitContext.class,0);
}
public TerminalNode ORDER() { return getToken(EsperEPL2GrammarParser.ORDER, 0); }
public OrderByListExprContext orderByListExpr() {
return getRuleContext(OrderByListExprContext.class,0);
}
public TerminalNode ROW_LIMIT_EXPR() { return getToken(EsperEPL2GrammarParser.ROW_LIMIT_EXPR, 0); }
public RowLimitContext rowLimit() {
return getRuleContext(RowLimitContext.class,0);
}
public SelectExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectExpr(this);
}
}
public final SelectExprContext selectExpr() throws RecognitionException {
SelectExprContext _localctx = new SelectExprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_selectExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(676);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(674);
match(INTO);
setState(675);
intoTableExpr();
}
}
setState(680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(678);
match(INSERT);
setState(679);
insertIntoExpr();
}
}
setState(682);
match(SELECT);
setState(683);
selectClause();
setState(686);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(684);
match(FROM);
setState(685);
fromClause();
}
}
setState(689);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MATCH_RECOGNIZE) {
{
setState(688);
matchRecog();
}
}
setState(693);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(691);
match(WHERE);
setState(692);
whereClause();
}
}
setState(698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(695);
match(GROUP);
setState(696);
match(BY);
setState(697);
groupByListExpr();
}
}
setState(702);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(700);
match(HAVING);
setState(701);
havingClause();
}
}
setState(706);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTPUT) {
{
setState(704);
match(OUTPUT);
setState(705);
outputLimit();
}
}
setState(711);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(708);
match(ORDER);
setState(709);
match(BY);
setState(710);
orderByListExpr();
}
}
setState(715);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW_LIMIT_EXPR) {
{
setState(713);
match(ROW_LIMIT_EXPR);
setState(714);
rowLimit();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnExprContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(EsperEPL2GrammarParser.ON, 0); }
public OnStreamExprContext onStreamExpr() {
return getRuleContext(OnStreamExprContext.class,0);
}
public OnDeleteExprContext onDeleteExpr() {
return getRuleContext(OnDeleteExprContext.class,0);
}
public OnSelectExprContext onSelectExpr() {
return getRuleContext(OnSelectExprContext.class,0);
}
public OnSetExprContext onSetExpr() {
return getRuleContext(OnSetExprContext.class,0);
}
public OnUpdateExprContext onUpdateExpr() {
return getRuleContext(OnUpdateExprContext.class,0);
}
public OnMergeExprContext onMergeExpr() {
return getRuleContext(OnMergeExprContext.class,0);
}
public List onSelectInsertExpr() {
return getRuleContexts(OnSelectInsertExprContext.class);
}
public OnSelectInsertExprContext onSelectInsertExpr(int i) {
return getRuleContext(OnSelectInsertExprContext.class,i);
}
public OutputClauseInsertContext outputClauseInsert() {
return getRuleContext(OutputClauseInsertContext.class,0);
}
public OnExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnExpr(this);
}
}
public final OnExprContext onExpr() throws RecognitionException {
OnExprContext _localctx = new OnExprContext(_ctx, getState());
enterRule(_localctx, 34, RULE_onExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(717);
match(ON);
setState(718);
onStreamExpr();
setState(734);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DELETE:
{
setState(719);
onDeleteExpr();
}
break;
case SELECT:
case INSERT:
{
setState(720);
onSelectExpr();
setState(729);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(722);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(721);
onSelectInsertExpr();
}
}
setState(724);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==INSERT );
setState(727);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTPUT) {
{
setState(726);
outputClauseInsert();
}
}
}
}
}
break;
case SET:
{
setState(731);
onSetExpr();
}
break;
case UPDATE:
{
setState(732);
onUpdateExpr();
}
break;
case MERGE:
{
setState(733);
onMergeExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnStreamExprContext extends ParserRuleContext {
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public PatternInclusionExpressionContext patternInclusionExpression() {
return getRuleContext(PatternInclusionExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public OnStreamExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onStreamExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnStreamExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnStreamExpr(this);
}
}
public final OnStreamExprContext onStreamExpr() throws RecognitionException {
OnStreamExprContext _localctx = new OnStreamExprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_onStreamExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(738);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(736);
eventFilterExpression();
}
break;
case PATTERN:
{
setState(737);
patternInclusionExpression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(743);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(740);
match(AS);
setState(741);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(742);
identOrTicked();
}
break;
case SELECT:
case INSERT:
case DELETE:
case SET:
case UPDATE:
case MERGE:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateExprContext extends ParserRuleContext {
public TerminalNode UPDATE() { return getToken(EsperEPL2GrammarParser.UPDATE, 0); }
public TerminalNode ISTREAM() { return getToken(EsperEPL2GrammarParser.ISTREAM, 0); }
public UpdateDetailsContext updateDetails() {
return getRuleContext(UpdateDetailsContext.class,0);
}
public UpdateExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUpdateExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUpdateExpr(this);
}
}
public final UpdateExprContext updateExpr() throws RecognitionException {
UpdateExprContext _localctx = new UpdateExprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_updateExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(745);
match(UPDATE);
setState(746);
match(ISTREAM);
setState(747);
updateDetails();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateDetailsContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public OnSetAssignmentListContext onSetAssignmentList() {
return getRuleContext(OnSetAssignmentListContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public UpdateDetailsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateDetails; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUpdateDetails(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUpdateDetails(this);
}
}
public final UpdateDetailsContext updateDetails() throws RecognitionException {
UpdateDetailsContext _localctx = new UpdateDetailsContext(_ctx, getState());
enterRule(_localctx, 40, RULE_updateDetails);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(749);
classIdentifier();
setState(753);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(750);
match(AS);
setState(751);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(752);
identOrTicked();
}
break;
case SET:
break;
default:
break;
}
setState(755);
match(SET);
setState(756);
onSetAssignmentList();
setState(759);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(757);
match(WHERE);
setState(758);
whereClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnMergeExprContext extends ParserRuleContext {
public Token n;
public TerminalNode MERGE() { return getToken(EsperEPL2GrammarParser.MERGE, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public OnMergeDirectInsertContext onMergeDirectInsert() {
return getRuleContext(OnMergeDirectInsertContext.class,0);
}
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List mergeItem() {
return getRuleContexts(MergeItemContext.class);
}
public MergeItemContext mergeItem(int i) {
return getRuleContext(MergeItemContext.class,i);
}
public OnMergeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onMergeExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnMergeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnMergeExpr(this);
}
}
public final OnMergeExprContext onMergeExpr() throws RecognitionException {
OnMergeExprContext _localctx = new OnMergeExprContext(_ctx, getState());
enterRule(_localctx, 42, RULE_onMergeExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(761);
match(MERGE);
setState(763);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(762);
match(INTO);
}
}
setState(765);
((OnMergeExprContext)_localctx).n = match(IDENT);
setState(769);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(766);
match(AS);
setState(767);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(768);
identOrTicked();
}
break;
case WHERE:
case WHEN:
case INSERT:
break;
default:
break;
}
setState(781);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INSERT:
{
setState(771);
onMergeDirectInsert();
}
break;
case WHERE:
case WHEN:
{
setState(774);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(772);
match(WHERE);
setState(773);
whereClause();
}
}
setState(777);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(776);
mergeItem();
}
}
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeItemContext extends ParserRuleContext {
public MergeMatchedContext mergeMatched() {
return getRuleContext(MergeMatchedContext.class,0);
}
public MergeUnmatchedContext mergeUnmatched() {
return getRuleContext(MergeUnmatchedContext.class,0);
}
public MergeItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeItem(this);
}
}
public final MergeItemContext mergeItem() throws RecognitionException {
MergeItemContext _localctx = new MergeItemContext(_ctx, getState());
enterRule(_localctx, 44, RULE_mergeItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(785);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(783);
mergeMatched();
}
break;
case 2:
{
setState(784);
mergeUnmatched();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeMatchedContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TerminalNode MATCHED() { return getToken(EsperEPL2GrammarParser.MATCHED, 0); }
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List mergeMatchedItem() {
return getRuleContexts(MergeMatchedItemContext.class);
}
public MergeMatchedItemContext mergeMatchedItem(int i) {
return getRuleContext(MergeMatchedItemContext.class,i);
}
public MergeMatchedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeMatched; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeMatched(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeMatched(this);
}
}
public final MergeMatchedContext mergeMatched() throws RecognitionException {
MergeMatchedContext _localctx = new MergeMatchedContext(_ctx, getState());
enterRule(_localctx, 46, RULE_mergeMatched);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(787);
match(WHEN);
setState(788);
match(MATCHED);
setState(791);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(789);
match(AND_EXPR);
setState(790);
expression();
}
}
setState(794);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(793);
mergeMatchedItem();
}
}
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==THEN );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeMatchedItemContext extends ParserRuleContext {
public Token u;
public Token d;
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public MergeInsertContext mergeInsert() {
return getRuleContext(MergeInsertContext.class,0);
}
public TerminalNode DELETE() { return getToken(EsperEPL2GrammarParser.DELETE, 0); }
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public OnSetAssignmentListContext onSetAssignmentList() {
return getRuleContext(OnSetAssignmentListContext.class,0);
}
public TerminalNode UPDATE() { return getToken(EsperEPL2GrammarParser.UPDATE, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public MergeMatchedItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeMatchedItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeMatchedItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeMatchedItem(this);
}
}
public final MergeMatchedItemContext mergeMatchedItem() throws RecognitionException {
MergeMatchedItemContext _localctx = new MergeMatchedItemContext(_ctx, getState());
enterRule(_localctx, 48, RULE_mergeMatchedItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(798);
match(THEN);
setState(813);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UPDATE:
{
{
setState(799);
((MergeMatchedItemContext)_localctx).u = match(UPDATE);
setState(800);
match(SET);
setState(801);
onSetAssignmentList();
}
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(803);
match(WHERE);
setState(804);
whereClause();
}
}
}
break;
case DELETE:
{
setState(807);
((MergeMatchedItemContext)_localctx).d = match(DELETE);
setState(810);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(808);
match(WHERE);
setState(809);
whereClause();
}
}
}
break;
case INSERT:
{
setState(812);
mergeInsert();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnMergeDirectInsertContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public OnMergeDirectInsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onMergeDirectInsert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnMergeDirectInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnMergeDirectInsert(this);
}
}
public final OnMergeDirectInsertContext onMergeDirectInsert() throws RecognitionException {
OnMergeDirectInsertContext _localctx = new OnMergeDirectInsertContext(_ctx, getState());
enterRule(_localctx, 50, RULE_onMergeDirectInsert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(815);
match(INSERT);
setState(820);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(816);
match(LPAREN);
setState(817);
columnList();
setState(818);
match(RPAREN);
}
}
setState(822);
match(SELECT);
setState(823);
selectionList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeUnmatchedContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TerminalNode NOT_EXPR() { return getToken(EsperEPL2GrammarParser.NOT_EXPR, 0); }
public TerminalNode MATCHED() { return getToken(EsperEPL2GrammarParser.MATCHED, 0); }
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List mergeUnmatchedItem() {
return getRuleContexts(MergeUnmatchedItemContext.class);
}
public MergeUnmatchedItemContext mergeUnmatchedItem(int i) {
return getRuleContext(MergeUnmatchedItemContext.class,i);
}
public MergeUnmatchedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeUnmatched; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeUnmatched(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeUnmatched(this);
}
}
public final MergeUnmatchedContext mergeUnmatched() throws RecognitionException {
MergeUnmatchedContext _localctx = new MergeUnmatchedContext(_ctx, getState());
enterRule(_localctx, 52, RULE_mergeUnmatched);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(825);
match(WHEN);
setState(826);
match(NOT_EXPR);
setState(827);
match(MATCHED);
setState(830);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(828);
match(AND_EXPR);
setState(829);
expression();
}
}
setState(833);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(832);
mergeUnmatchedItem();
}
}
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==THEN );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeUnmatchedItemContext extends ParserRuleContext {
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public MergeInsertContext mergeInsert() {
return getRuleContext(MergeInsertContext.class,0);
}
public MergeUnmatchedItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeUnmatchedItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeUnmatchedItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeUnmatchedItem(this);
}
}
public final MergeUnmatchedItemContext mergeUnmatchedItem() throws RecognitionException {
MergeUnmatchedItemContext _localctx = new MergeUnmatchedItemContext(_ctx, getState());
enterRule(_localctx, 54, RULE_mergeUnmatchedItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(837);
match(THEN);
setState(838);
mergeInsert();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeInsertContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public InsertIntoEventPrecedenceContext insertIntoEventPrecedence() {
return getRuleContext(InsertIntoEventPrecedenceContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public MergeInsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeInsert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeInsert(this);
}
}
public final MergeInsertContext mergeInsert() throws RecognitionException {
MergeInsertContext _localctx = new MergeInsertContext(_ctx, getState());
enterRule(_localctx, 56, RULE_mergeInsert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(840);
match(INSERT);
setState(843);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(841);
match(INTO);
setState(842);
classIdentifier();
}
}
setState(849);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(845);
match(LPAREN);
setState(846);
columnList();
setState(847);
match(RPAREN);
}
}
setState(852);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EVENTPRECEDENCE) {
{
setState(851);
insertIntoEventPrecedence();
}
}
setState(854);
match(SELECT);
setState(855);
selectionList();
setState(858);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(856);
match(WHERE);
setState(857);
whereClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSelectExprContext extends ParserRuleContext {
public Token d;
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public InsertIntoExprContext insertIntoExpr() {
return getRuleContext(InsertIntoExprContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public OnExprFromContext onExprFrom() {
return getRuleContext(OnExprFromContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode GROUP() { return getToken(EsperEPL2GrammarParser.GROUP, 0); }
public List BY() { return getTokens(EsperEPL2GrammarParser.BY); }
public TerminalNode BY(int i) {
return getToken(EsperEPL2GrammarParser.BY, i);
}
public GroupByListExprContext groupByListExpr() {
return getRuleContext(GroupByListExprContext.class,0);
}
public TerminalNode HAVING() { return getToken(EsperEPL2GrammarParser.HAVING, 0); }
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public TerminalNode ORDER() { return getToken(EsperEPL2GrammarParser.ORDER, 0); }
public OrderByListExprContext orderByListExpr() {
return getRuleContext(OrderByListExprContext.class,0);
}
public TerminalNode ROW_LIMIT_EXPR() { return getToken(EsperEPL2GrammarParser.ROW_LIMIT_EXPR, 0); }
public RowLimitContext rowLimit() {
return getRuleContext(RowLimitContext.class,0);
}
public TerminalNode DELETE() { return getToken(EsperEPL2GrammarParser.DELETE, 0); }
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public OnSelectExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSelectExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSelectExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSelectExpr(this);
}
}
public final OnSelectExprContext onSelectExpr() throws RecognitionException {
OnSelectExprContext _localctx = new OnSelectExprContext(_ctx, getState());
enterRule(_localctx, 58, RULE_onSelectExpr);
paraphrases.push("on-select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(862);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(860);
match(INSERT);
setState(861);
insertIntoExpr();
}
}
setState(864);
match(SELECT);
setState(869);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR || _la==DELETE) {
{
setState(866);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(865);
match(AND_EXPR);
}
}
setState(868);
((OnSelectExprContext)_localctx).d = match(DELETE);
}
}
setState(872);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(871);
match(DISTINCT);
}
}
setState(874);
selectionList();
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(875);
onExprFrom();
}
}
setState(880);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(878);
match(WHERE);
setState(879);
whereClause();
}
}
setState(885);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(882);
match(GROUP);
setState(883);
match(BY);
setState(884);
groupByListExpr();
}
}
setState(889);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(887);
match(HAVING);
setState(888);
havingClause();
}
}
setState(894);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(891);
match(ORDER);
setState(892);
match(BY);
setState(893);
orderByListExpr();
}
}
setState(898);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW_LIMIT_EXPR) {
{
setState(896);
match(ROW_LIMIT_EXPR);
setState(897);
rowLimit();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnUpdateExprContext extends ParserRuleContext {
public Token n;
public TerminalNode UPDATE() { return getToken(EsperEPL2GrammarParser.UPDATE, 0); }
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public OnSetAssignmentListContext onSetAssignmentList() {
return getRuleContext(OnSetAssignmentListContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public OnUpdateExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onUpdateExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnUpdateExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnUpdateExpr(this);
}
}
public final OnUpdateExprContext onUpdateExpr() throws RecognitionException {
OnUpdateExprContext _localctx = new OnUpdateExprContext(_ctx, getState());
enterRule(_localctx, 60, RULE_onUpdateExpr);
paraphrases.push("on-update clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(900);
match(UPDATE);
setState(901);
((OnUpdateExprContext)_localctx).n = match(IDENT);
setState(905);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(902);
match(AS);
setState(903);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(904);
identOrTicked();
}
break;
case SET:
break;
default:
break;
}
setState(907);
match(SET);
setState(908);
onSetAssignmentList();
setState(911);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(909);
match(WHERE);
setState(910);
whereClause();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSelectInsertExprContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public InsertIntoExprContext insertIntoExpr() {
return getRuleContext(InsertIntoExprContext.class,0);
}
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public OnSelectInsertFromClauseContext onSelectInsertFromClause() {
return getRuleContext(OnSelectInsertFromClauseContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public OnSelectInsertExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSelectInsertExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSelectInsertExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSelectInsertExpr(this);
}
}
public final OnSelectInsertExprContext onSelectInsertExpr() throws RecognitionException {
OnSelectInsertExprContext _localctx = new OnSelectInsertExprContext(_ctx, getState());
enterRule(_localctx, 62, RULE_onSelectInsertExpr);
paraphrases.push("on-select-insert clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(913);
match(INSERT);
setState(914);
insertIntoExpr();
setState(915);
match(SELECT);
setState(916);
selectionList();
setState(918);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(917);
onSelectInsertFromClause();
}
}
setState(922);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(920);
match(WHERE);
setState(921);
whereClause();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSelectInsertFromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public PropertyExpressionContext propertyExpression() {
return getRuleContext(PropertyExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public OnSelectInsertFromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSelectInsertFromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSelectInsertFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSelectInsertFromClause(this);
}
}
public final OnSelectInsertFromClauseContext onSelectInsertFromClause() throws RecognitionException {
OnSelectInsertFromClauseContext _localctx = new OnSelectInsertFromClauseContext(_ctx, getState());
enterRule(_localctx, 64, RULE_onSelectInsertFromClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(924);
match(FROM);
setState(925);
propertyExpression();
setState(929);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(926);
match(AS);
setState(927);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(928);
identOrTicked();
}
break;
case EOF:
case WHERE:
case OUTPUT:
case INSERT:
case FOR:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputClauseInsertContext extends ParserRuleContext {
public Token f;
public Token a;
public TerminalNode OUTPUT() { return getToken(EsperEPL2GrammarParser.OUTPUT, 0); }
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public OutputClauseInsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputClauseInsert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOutputClauseInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOutputClauseInsert(this);
}
}
public final OutputClauseInsertContext outputClauseInsert() throws RecognitionException {
OutputClauseInsertContext _localctx = new OutputClauseInsertContext(_ctx, getState());
enterRule(_localctx, 66, RULE_outputClauseInsert);
try {
enterOuterAlt(_localctx, 1);
{
setState(931);
match(OUTPUT);
setState(934);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FIRST:
{
setState(932);
((OutputClauseInsertContext)_localctx).f = match(FIRST);
}
break;
case ALL:
{
setState(933);
((OutputClauseInsertContext)_localctx).a = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnDeleteExprContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(EsperEPL2GrammarParser.DELETE, 0); }
public OnExprFromContext onExprFrom() {
return getRuleContext(OnExprFromContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public OnDeleteExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onDeleteExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnDeleteExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnDeleteExpr(this);
}
}
public final OnDeleteExprContext onDeleteExpr() throws RecognitionException {
OnDeleteExprContext _localctx = new OnDeleteExprContext(_ctx, getState());
enterRule(_localctx, 68, RULE_onDeleteExpr);
paraphrases.push("on-delete clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(936);
match(DELETE);
setState(937);
onExprFrom();
setState(940);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(938);
match(WHERE);
setState(939);
whereClause();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSetExprContext extends ParserRuleContext {
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public OnSetAssignmentListContext onSetAssignmentList() {
return getRuleContext(OnSetAssignmentListContext.class,0);
}
public OnSetExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSetExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSetExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSetExpr(this);
}
}
public final OnSetExprContext onSetExpr() throws RecognitionException {
OnSetExprContext _localctx = new OnSetExprContext(_ctx, getState());
enterRule(_localctx, 70, RULE_onSetExpr);
paraphrases.push("on-set clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(942);
match(SET);
setState(943);
onSetAssignmentList();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSetAssignmentListContext extends ParserRuleContext {
public List onSetAssignment() {
return getRuleContexts(OnSetAssignmentContext.class);
}
public OnSetAssignmentContext onSetAssignment(int i) {
return getRuleContext(OnSetAssignmentContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public OnSetAssignmentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSetAssignmentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSetAssignmentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSetAssignmentList(this);
}
}
public final OnSetAssignmentListContext onSetAssignmentList() throws RecognitionException {
OnSetAssignmentListContext _localctx = new OnSetAssignmentListContext(_ctx, getState());
enterRule(_localctx, 72, RULE_onSetAssignmentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(945);
onSetAssignment();
setState(950);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(946);
match(COMMA);
setState(947);
onSetAssignment();
}
}
setState(952);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSetAssignmentContext extends ParserRuleContext {
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public OnSetAssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSetAssignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSetAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSetAssignment(this);
}
}
public final OnSetAssignmentContext onSetAssignment() throws RecognitionException {
OnSetAssignmentContext _localctx = new OnSetAssignmentContext(_ctx, getState());
enterRule(_localctx, 74, RULE_onSetAssignment);
try {
setState(958);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(953);
chainable();
setState(954);
match(EQUALS);
setState(955);
expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(957);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnExprFromContext extends ParserRuleContext {
public Token n;
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public OnExprFromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onExprFrom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnExprFrom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnExprFrom(this);
}
}
public final OnExprFromContext onExprFrom() throws RecognitionException {
OnExprFromContext _localctx = new OnExprFromContext(_ctx, getState());
enterRule(_localctx, 76, RULE_onExprFrom);
try {
enterOuterAlt(_localctx, 1);
{
setState(960);
match(FROM);
setState(961);
((OnExprFromContext)_localctx).n = match(IDENT);
setState(965);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(962);
match(AS);
setState(963);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(964);
identOrTicked();
}
break;
case EOF:
case WHERE:
case GROUP:
case HAVING:
case INSERT:
case ORDER:
case ROW_LIMIT_EXPR:
case FOR:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateWindowExprContext extends ParserRuleContext {
public Token i;
public Token ru;
public Token ri;
public Token i1;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode WINDOW() { return getToken(EsperEPL2GrammarParser.WINDOW, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CreateWindowExprModelAfterContext createWindowExprModelAfter() {
return getRuleContext(CreateWindowExprModelAfterContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public CreateColumnListContext createColumnList() {
return getRuleContext(CreateColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ViewExpressionsContext viewExpressions() {
return getRuleContext(ViewExpressionsContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public CreateWindowExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createWindowExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateWindowExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateWindowExpr(this);
}
}
public final CreateWindowExprContext createWindowExpr() throws RecognitionException {
CreateWindowExprContext _localctx = new CreateWindowExprContext(_ctx, getState());
enterRule(_localctx, 78, RULE_createWindowExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(967);
match(CREATE);
setState(968);
match(WINDOW);
setState(969);
((CreateWindowExprContext)_localctx).i = match(IDENT);
setState(971);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(970);
viewExpressions();
}
}
setState(975);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(973);
((CreateWindowExprContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(974);
((CreateWindowExprContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case AS:
case SELECT:
case EVENTS:
case LPAREN:
case TICKED_STRING_LITERAL:
case IDENT:
break;
default:
break;
}
setState(978);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(977);
match(AS);
}
}
setState(985);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(980);
createWindowExprModelAfter();
}
break;
case LPAREN:
{
setState(981);
match(LPAREN);
setState(982);
createColumnList();
setState(983);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(992);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(987);
((CreateWindowExprContext)_localctx).i1 = match(INSERT);
setState(990);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(988);
match(WHERE);
setState(989);
expression();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateWindowExprModelAfterContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public CreateSelectionListContext createSelectionList() {
return getRuleContext(CreateSelectionListContext.class,0);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public CreateWindowExprModelAfterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createWindowExprModelAfter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateWindowExprModelAfter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateWindowExprModelAfter(this);
}
}
public final CreateWindowExprModelAfterContext createWindowExprModelAfter() throws RecognitionException {
CreateWindowExprModelAfterContext _localctx = new CreateWindowExprModelAfterContext(_ctx, getState());
enterRule(_localctx, 80, RULE_createWindowExprModelAfter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(998);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(994);
match(SELECT);
setState(995);
createSelectionList();
setState(996);
match(FROM);
}
}
setState(1000);
classIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateIndexExprContext extends ParserRuleContext {
public Token u;
public Token n;
public Token w;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode INDEX() { return getToken(EsperEPL2GrammarParser.INDEX, 0); }
public TerminalNode ON() { return getToken(EsperEPL2GrammarParser.ON, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public CreateIndexColumnListContext createIndexColumnList() {
return getRuleContext(CreateIndexColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public CreateIndexExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndexExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateIndexExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateIndexExpr(this);
}
}
public final CreateIndexExprContext createIndexExpr() throws RecognitionException {
CreateIndexExprContext _localctx = new CreateIndexExprContext(_ctx, getState());
enterRule(_localctx, 82, RULE_createIndexExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1002);
match(CREATE);
setState(1004);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1003);
((CreateIndexExprContext)_localctx).u = match(IDENT);
}
}
setState(1006);
match(INDEX);
setState(1007);
((CreateIndexExprContext)_localctx).n = match(IDENT);
setState(1008);
match(ON);
setState(1009);
((CreateIndexExprContext)_localctx).w = match(IDENT);
setState(1010);
match(LPAREN);
setState(1011);
createIndexColumnList();
setState(1012);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateIndexColumnListContext extends ParserRuleContext {
public List createIndexColumn() {
return getRuleContexts(CreateIndexColumnContext.class);
}
public CreateIndexColumnContext createIndexColumn(int i) {
return getRuleContext(CreateIndexColumnContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateIndexColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndexColumnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateIndexColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateIndexColumnList(this);
}
}
public final CreateIndexColumnListContext createIndexColumnList() throws RecognitionException {
CreateIndexColumnListContext _localctx = new CreateIndexColumnListContext(_ctx, getState());
enterRule(_localctx, 84, RULE_createIndexColumnList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1014);
createIndexColumn();
setState(1019);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1015);
match(COMMA);
setState(1016);
createIndexColumn();
}
}
setState(1021);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateIndexColumnContext extends ParserRuleContext {
public ExpressionListContext i;
public Token t;
public ExpressionListContext p;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public List RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public CreateIndexColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndexColumn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateIndexColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateIndexColumn(this);
}
}
public final CreateIndexColumnContext createIndexColumn() throws RecognitionException {
CreateIndexColumnContext _localctx = new CreateIndexColumnContext(_ctx, getState());
enterRule(_localctx, 86, RULE_createIndexColumn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1028);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(1022);
expression();
}
break;
case 2:
{
setState(1023);
match(LPAREN);
setState(1025);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1024);
((CreateIndexColumnContext)_localctx).i = expressionList();
}
}
setState(1027);
match(RPAREN);
}
break;
}
setState(1038);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1030);
((CreateIndexColumnContext)_localctx).t = match(IDENT);
setState(1036);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1031);
match(LPAREN);
setState(1033);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1032);
((CreateIndexColumnContext)_localctx).p = expressionList();
}
}
setState(1035);
match(RPAREN);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateVariableExprContext extends ParserRuleContext {
public Token c;
public Token n;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode VARIABLE() { return getToken(EsperEPL2GrammarParser.VARIABLE, 0); }
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public CreateVariableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createVariableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateVariableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateVariableExpr(this);
}
}
public final CreateVariableExprContext createVariableExpr() throws RecognitionException {
CreateVariableExprContext _localctx = new CreateVariableExprContext(_ctx, getState());
enterRule(_localctx, 88, RULE_createVariableExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1040);
match(CREATE);
setState(1042);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1041);
((CreateVariableExprContext)_localctx).c = match(IDENT);
}
}
setState(1044);
match(VARIABLE);
setState(1045);
classIdentifierWithDimensions();
setState(1046);
((CreateVariableExprContext)_localctx).n = match(IDENT);
setState(1049);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(1047);
match(EQUALS);
setState(1048);
expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableExprContext extends ParserRuleContext {
public Token n;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(EsperEPL2GrammarParser.TABLE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public CreateTableColumnListContext createTableColumnList() {
return getRuleContext(CreateTableColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CreateTableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateTableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateTableExpr(this);
}
}
public final CreateTableExprContext createTableExpr() throws RecognitionException {
CreateTableExprContext _localctx = new CreateTableExprContext(_ctx, getState());
enterRule(_localctx, 90, RULE_createTableExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1051);
match(CREATE);
setState(1052);
match(TABLE);
setState(1053);
((CreateTableExprContext)_localctx).n = match(IDENT);
setState(1055);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1054);
match(AS);
}
}
setState(1057);
match(LPAREN);
setState(1058);
createTableColumnList();
setState(1059);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableColumnListContext extends ParserRuleContext {
public List createTableColumn() {
return getRuleContexts(CreateTableColumnContext.class);
}
public CreateTableColumnContext createTableColumn(int i) {
return getRuleContext(CreateTableColumnContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateTableColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableColumnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateTableColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateTableColumnList(this);
}
}
public final CreateTableColumnListContext createTableColumnList() throws RecognitionException {
CreateTableColumnListContext _localctx = new CreateTableColumnListContext(_ctx, getState());
enterRule(_localctx, 92, RULE_createTableColumnList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1061);
createTableColumn();
setState(1066);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1062);
match(COMMA);
setState(1063);
createTableColumn();
}
}
setState(1068);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableColumnContext extends ParserRuleContext {
public Token n;
public Token p;
public Token k;
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public BuiltinFuncContext builtinFunc() {
return getRuleContext(BuiltinFuncContext.class,0);
}
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public List typeExpressionAnnotation() {
return getRuleContexts(TypeExpressionAnnotationContext.class);
}
public TypeExpressionAnnotationContext typeExpressionAnnotation(int i) {
return getRuleContext(TypeExpressionAnnotationContext.class,i);
}
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public CreateTableColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableColumn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateTableColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateTableColumn(this);
}
}
public final CreateTableColumnContext createTableColumn() throws RecognitionException {
CreateTableColumnContext _localctx = new CreateTableColumnContext(_ctx, getState());
enterRule(_localctx, 94, RULE_createTableColumn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1069);
((CreateTableColumnContext)_localctx).n = match(IDENT);
setState(1073);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(1070);
classIdentifierWithDimensions();
}
break;
case 2:
{
setState(1071);
builtinFunc();
}
break;
case 3:
{
setState(1072);
chainable();
}
break;
}
setState(1076);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(1075);
((CreateTableColumnContext)_localctx).p = match(IDENT);
}
break;
}
setState(1079);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1078);
((CreateTableColumnContext)_localctx).k = match(IDENT);
}
}
setState(1085);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
setState(1083);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1081);
typeExpressionAnnotation();
}
break;
case 2:
{
setState(1082);
annotationEnum();
}
break;
}
}
setState(1087);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateColumnListContext extends ParserRuleContext {
public List createColumnListElement() {
return getRuleContexts(CreateColumnListElementContext.class);
}
public CreateColumnListElementContext createColumnListElement(int i) {
return getRuleContext(CreateColumnListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createColumnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateColumnList(this);
}
}
public final CreateColumnListContext createColumnList() throws RecognitionException {
CreateColumnListContext _localctx = new CreateColumnListContext(_ctx, getState());
enterRule(_localctx, 96, RULE_createColumnList);
paraphrases.push("column list");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1088);
createColumnListElement();
setState(1093);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1089);
match(COMMA);
setState(1090);
createColumnListElement();
}
}
setState(1095);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateColumnListElementContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode VALUE_NULL() { return getToken(EsperEPL2GrammarParser.VALUE_NULL, 0); }
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public CreateColumnListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createColumnListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateColumnListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateColumnListElement(this);
}
}
public final CreateColumnListElementContext createColumnListElement() throws RecognitionException {
CreateColumnListElementContext _localctx = new CreateColumnListElementContext(_ctx, getState());
enterRule(_localctx, 98, RULE_createColumnListElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1096);
classIdentifier();
setState(1099);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VALUE_NULL:
{
setState(1097);
match(VALUE_NULL);
}
break;
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1098);
classIdentifierWithDimensions();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSelectionListContext extends ParserRuleContext {
public List createSelectionListElement() {
return getRuleContexts(CreateSelectionListElementContext.class);
}
public CreateSelectionListElementContext createSelectionListElement(int i) {
return getRuleContext(CreateSelectionListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateSelectionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSelectionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSelectionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSelectionList(this);
}
}
public final CreateSelectionListContext createSelectionList() throws RecognitionException {
CreateSelectionListContext _localctx = new CreateSelectionListContext(_ctx, getState());
enterRule(_localctx, 100, RULE_createSelectionList);
paraphrases.push("select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1101);
createSelectionListElement();
setState(1106);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1102);
match(COMMA);
setState(1103);
createSelectionListElement();
}
}
setState(1108);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSelectionListElementContext extends ParserRuleContext {
public Token s;
public Token i;
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public CreateSelectionListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSelectionListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSelectionListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSelectionListElement(this);
}
}
public final CreateSelectionListElementContext createSelectionListElement() throws RecognitionException {
CreateSelectionListElementContext _localctx = new CreateSelectionListElementContext(_ctx, getState());
enterRule(_localctx, 102, RULE_createSelectionListElement);
int _la;
try {
setState(1119);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1109);
((CreateSelectionListElementContext)_localctx).s = match(STAR);
}
break;
case WINDOW:
case BETWEEN:
case ESCAPE:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PRIOR:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case CONTEXT:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1110);
chainable();
setState(1113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1111);
match(AS);
setState(1112);
((CreateSelectionListElementContext)_localctx).i = match(IDENT);
}
}
}
break;
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case PLUS:
case MINUS:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 3);
{
setState(1115);
constant();
setState(1116);
match(AS);
setState(1117);
((CreateSelectionListElementContext)_localctx).i = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSchemaExprContext extends ParserRuleContext {
public Token keyword;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public CreateSchemaDefContext createSchemaDef() {
return getRuleContext(CreateSchemaDefContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CreateSchemaExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSchemaExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSchemaExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSchemaExpr(this);
}
}
public final CreateSchemaExprContext createSchemaExpr() throws RecognitionException {
CreateSchemaExprContext _localctx = new CreateSchemaExprContext(_ctx, getState());
enterRule(_localctx, 104, RULE_createSchemaExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1121);
match(CREATE);
setState(1123);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1122);
((CreateSchemaExprContext)_localctx).keyword = match(IDENT);
}
}
setState(1125);
createSchemaDef();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSchemaDefContext extends ParserRuleContext {
public Token name;
public TerminalNode SCHEMA() { return getToken(EsperEPL2GrammarParser.SCHEMA, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public VariantListContext variantList() {
return getRuleContext(VariantListContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public List createSchemaQual() {
return getRuleContexts(CreateSchemaQualContext.class);
}
public CreateSchemaQualContext createSchemaQual(int i) {
return getRuleContext(CreateSchemaQualContext.class,i);
}
public CreateColumnListContext createColumnList() {
return getRuleContext(CreateColumnListContext.class,0);
}
public CreateSchemaDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSchemaDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSchemaDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSchemaDef(this);
}
}
public final CreateSchemaDefContext createSchemaDef() throws RecognitionException {
CreateSchemaDefContext _localctx = new CreateSchemaDefContext(_ctx, getState());
enterRule(_localctx, 106, RULE_createSchemaDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1127);
match(SCHEMA);
setState(1128);
((CreateSchemaDefContext)_localctx).name = match(IDENT);
setState(1130);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1129);
match(AS);
}
}
setState(1138);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case STAR:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1132);
variantList();
}
break;
case LPAREN:
{
setState(1133);
match(LPAREN);
setState(1135);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EVENTS || _la==TICKED_STRING_LITERAL || _la==IDENT) {
{
setState(1134);
createColumnList();
}
}
setState(1137);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1143);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENT) {
{
{
setState(1140);
createSchemaQual();
}
}
setState(1145);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FafDeleteContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(EsperEPL2GrammarParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public FafDeleteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fafDelete; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFafDelete(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFafDelete(this);
}
}
public final FafDeleteContext fafDelete() throws RecognitionException {
FafDeleteContext _localctx = new FafDeleteContext(_ctx, getState());
enterRule(_localctx, 108, RULE_fafDelete);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1146);
match(DELETE);
setState(1147);
match(FROM);
setState(1148);
classIdentifier();
setState(1152);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(1149);
match(AS);
setState(1150);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1151);
identOrTicked();
}
break;
case EOF:
case WHERE:
case FOR:
break;
default:
break;
}
setState(1156);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1154);
match(WHERE);
setState(1155);
whereClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FafUpdateContext extends ParserRuleContext {
public TerminalNode UPDATE() { return getToken(EsperEPL2GrammarParser.UPDATE, 0); }
public UpdateDetailsContext updateDetails() {
return getRuleContext(UpdateDetailsContext.class,0);
}
public FafUpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fafUpdate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFafUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFafUpdate(this);
}
}
public final FafUpdateContext fafUpdate() throws RecognitionException {
FafUpdateContext _localctx = new FafUpdateContext(_ctx, getState());
enterRule(_localctx, 110, RULE_fafUpdate);
try {
enterOuterAlt(_localctx, 1);
{
setState(1158);
match(UPDATE);
setState(1159);
updateDetails();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FafInsertContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public InsertIntoExprContext insertIntoExpr() {
return getRuleContext(InsertIntoExprContext.class,0);
}
public TerminalNode VALUES() { return getToken(EsperEPL2GrammarParser.VALUES, 0); }
public List fafInsertRow() {
return getRuleContexts(FafInsertRowContext.class);
}
public FafInsertRowContext fafInsertRow(int i) {
return getRuleContext(FafInsertRowContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public FafInsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fafInsert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFafInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFafInsert(this);
}
}
public final FafInsertContext fafInsert() throws RecognitionException {
FafInsertContext _localctx = new FafInsertContext(_ctx, getState());
enterRule(_localctx, 112, RULE_fafInsert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1161);
match(INSERT);
setState(1162);
insertIntoExpr();
setState(1163);
match(VALUES);
setState(1164);
fafInsertRow();
setState(1169);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1165);
match(COMMA);
setState(1166);
fafInsertRow();
}
}
setState(1171);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FafInsertRowContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public FafInsertRowContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fafInsertRow; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFafInsertRow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFafInsertRow(this);
}
}
public final FafInsertRowContext fafInsertRow() throws RecognitionException {
FafInsertRowContext _localctx = new FafInsertRowContext(_ctx, getState());
enterRule(_localctx, 114, RULE_fafInsertRow);
try {
enterOuterAlt(_localctx, 1);
{
setState(1172);
match(LPAREN);
setState(1173);
expressionList();
setState(1174);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateDataflowContext extends ParserRuleContext {
public Token name;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode DATAFLOW() { return getToken(EsperEPL2GrammarParser.DATAFLOW, 0); }
public GopListContext gopList() {
return getRuleContext(GopListContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CreateDataflowContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createDataflow; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateDataflow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateDataflow(this);
}
}
public final CreateDataflowContext createDataflow() throws RecognitionException {
CreateDataflowContext _localctx = new CreateDataflowContext(_ctx, getState());
enterRule(_localctx, 116, RULE_createDataflow);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1176);
match(CREATE);
setState(1177);
match(DATAFLOW);
setState(1178);
((CreateDataflowContext)_localctx).name = match(IDENT);
setState(1180);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1179);
match(AS);
}
}
setState(1182);
gopList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopListContext extends ParserRuleContext {
public List gop() {
return getRuleContexts(GopContext.class);
}
public GopContext gop(int i) {
return getRuleContext(GopContext.class,i);
}
public GopListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopList(this);
}
}
public final GopListContext gopList() throws RecognitionException {
GopListContext _localctx = new GopListContext(_ctx, getState());
enterRule(_localctx, 118, RULE_gopList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1184);
gop();
setState(1188);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CREATE || _la==SELECT || _la==ATCHAR || _la==IDENT) {
{
{
setState(1185);
gop();
}
}
setState(1190);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopContext extends ParserRuleContext {
public Token opName;
public Token s;
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public GopParamsContext gopParams() {
return getRuleContext(GopParamsContext.class,0);
}
public GopOutContext gopOut() {
return getRuleContext(GopOutContext.class,0);
}
public GopDetailContext gopDetail() {
return getRuleContext(GopDetailContext.class,0);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public CreateSchemaExprContext createSchemaExpr() {
return getRuleContext(CreateSchemaExprContext.class,0);
}
public GopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGop(this);
}
}
public final GopContext gop() throws RecognitionException {
GopContext _localctx = new GopContext(_ctx, getState());
enterRule(_localctx, 120, RULE_gop);
int _la;
try {
setState(1218);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
case ATCHAR:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(1194);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
{
setState(1191);
annotationEnum();
}
}
setState(1196);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1199);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(1197);
((GopContext)_localctx).opName = match(IDENT);
}
break;
case SELECT:
{
setState(1198);
((GopContext)_localctx).s = match(SELECT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1202);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1201);
gopParams();
}
}
setState(1205);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOLLOWED_BY) {
{
setState(1204);
gopOut();
}
}
setState(1207);
match(LCURLY);
setState(1209);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT || _la==IDENT) {
{
setState(1208);
gopDetail();
}
}
setState(1212);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1211);
match(COMMA);
}
}
setState(1214);
match(RCURLY);
}
break;
case CREATE:
enterOuterAlt(_localctx, 2);
{
setState(1215);
createSchemaExpr();
setState(1216);
match(COMMA);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public GopParamsItemListContext gopParamsItemList() {
return getRuleContext(GopParamsItemListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public GopParamsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParams; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParams(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParams(this);
}
}
public final GopParamsContext gopParams() throws RecognitionException {
GopParamsContext _localctx = new GopParamsContext(_ctx, getState());
enterRule(_localctx, 122, RULE_gopParams);
try {
enterOuterAlt(_localctx, 1);
{
setState(1220);
match(LPAREN);
setState(1221);
gopParamsItemList();
setState(1222);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsItemListContext extends ParserRuleContext {
public List gopParamsItem() {
return getRuleContexts(GopParamsItemContext.class);
}
public GopParamsItemContext gopParamsItem(int i) {
return getRuleContext(GopParamsItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopParamsItemListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParamsItemList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParamsItemList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParamsItemList(this);
}
}
public final GopParamsItemListContext gopParamsItemList() throws RecognitionException {
GopParamsItemListContext _localctx = new GopParamsItemListContext(_ctx, getState());
enterRule(_localctx, 124, RULE_gopParamsItemList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1224);
gopParamsItem();
setState(1229);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1225);
match(COMMA);
setState(1226);
gopParamsItem();
}
}
setState(1231);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsItemContext extends ParserRuleContext {
public ClassIdentifierContext n;
public GopParamsItemManyContext gopParamsItemMany() {
return getRuleContext(GopParamsItemManyContext.class,0);
}
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public GopParamsItemAsContext gopParamsItemAs() {
return getRuleContext(GopParamsItemAsContext.class,0);
}
public GopParamsItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParamsItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParamsItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParamsItem(this);
}
}
public final GopParamsItemContext gopParamsItem() throws RecognitionException {
GopParamsItemContext _localctx = new GopParamsItemContext(_ctx, getState());
enterRule(_localctx, 126, RULE_gopParamsItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1234);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1232);
((GopParamsItemContext)_localctx).n = classIdentifier();
}
break;
case LPAREN:
{
setState(1233);
gopParamsItemMany();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1237);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1236);
gopParamsItemAs();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsItemManyContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List classIdentifier() {
return getRuleContexts(ClassIdentifierContext.class);
}
public ClassIdentifierContext classIdentifier(int i) {
return getRuleContext(ClassIdentifierContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public GopParamsItemManyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParamsItemMany; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParamsItemMany(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParamsItemMany(this);
}
}
public final GopParamsItemManyContext gopParamsItemMany() throws RecognitionException {
GopParamsItemManyContext _localctx = new GopParamsItemManyContext(_ctx, getState());
enterRule(_localctx, 128, RULE_gopParamsItemMany);
try {
enterOuterAlt(_localctx, 1);
{
setState(1239);
match(LPAREN);
setState(1240);
classIdentifier();
{
setState(1241);
match(COMMA);
setState(1242);
classIdentifier();
}
setState(1244);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsItemAsContext extends ParserRuleContext {
public Token a;
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public GopParamsItemAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParamsItemAs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParamsItemAs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParamsItemAs(this);
}
}
public final GopParamsItemAsContext gopParamsItemAs() throws RecognitionException {
GopParamsItemAsContext _localctx = new GopParamsItemAsContext(_ctx, getState());
enterRule(_localctx, 130, RULE_gopParamsItemAs);
try {
enterOuterAlt(_localctx, 1);
{
setState(1246);
match(AS);
setState(1247);
((GopParamsItemAsContext)_localctx).a = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutContext extends ParserRuleContext {
public TerminalNode FOLLOWED_BY() { return getToken(EsperEPL2GrammarParser.FOLLOWED_BY, 0); }
public List gopOutItem() {
return getRuleContexts(GopOutItemContext.class);
}
public GopOutItemContext gopOutItem(int i) {
return getRuleContext(GopOutItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopOutContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOut; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOut(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOut(this);
}
}
public final GopOutContext gopOut() throws RecognitionException {
GopOutContext _localctx = new GopOutContext(_ctx, getState());
enterRule(_localctx, 132, RULE_gopOut);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1249);
match(FOLLOWED_BY);
setState(1250);
gopOutItem();
setState(1255);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1251);
match(COMMA);
setState(1252);
gopOutItem();
}
}
setState(1257);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutItemContext extends ParserRuleContext {
public ClassIdentifierContext n;
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public GopOutTypeListContext gopOutTypeList() {
return getRuleContext(GopOutTypeListContext.class,0);
}
public GopOutItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOutItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOutItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOutItem(this);
}
}
public final GopOutItemContext gopOutItem() throws RecognitionException {
GopOutItemContext _localctx = new GopOutItemContext(_ctx, getState());
enterRule(_localctx, 134, RULE_gopOutItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1258);
((GopOutItemContext)_localctx).n = classIdentifier();
setState(1260);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1259);
gopOutTypeList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutTypeListContext extends ParserRuleContext {
public TerminalNode LT() { return getToken(EsperEPL2GrammarParser.LT, 0); }
public List gopOutTypeParam() {
return getRuleContexts(GopOutTypeParamContext.class);
}
public GopOutTypeParamContext gopOutTypeParam(int i) {
return getRuleContext(GopOutTypeParamContext.class,i);
}
public TerminalNode GT() { return getToken(EsperEPL2GrammarParser.GT, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopOutTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOutTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOutTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOutTypeList(this);
}
}
public final GopOutTypeListContext gopOutTypeList() throws RecognitionException {
GopOutTypeListContext _localctx = new GopOutTypeListContext(_ctx, getState());
enterRule(_localctx, 136, RULE_gopOutTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1262);
match(LT);
setState(1263);
gopOutTypeParam();
setState(1268);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1264);
match(COMMA);
setState(1265);
gopOutTypeParam();
}
}
setState(1270);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1271);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutTypeParamContext extends ParserRuleContext {
public Token q;
public GopOutTypeItemContext gopOutTypeItem() {
return getRuleContext(GopOutTypeItemContext.class,0);
}
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public GopOutTypeParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOutTypeParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOutTypeParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOutTypeParam(this);
}
}
public final GopOutTypeParamContext gopOutTypeParam() throws RecognitionException {
GopOutTypeParamContext _localctx = new GopOutTypeParamContext(_ctx, getState());
enterRule(_localctx, 138, RULE_gopOutTypeParam);
try {
enterOuterAlt(_localctx, 1);
{
setState(1275);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1273);
gopOutTypeItem();
}
break;
case QUESTION:
{
setState(1274);
((GopOutTypeParamContext)_localctx).q = match(QUESTION);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutTypeItemContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public GopOutTypeListContext gopOutTypeList() {
return getRuleContext(GopOutTypeListContext.class,0);
}
public GopOutTypeItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOutTypeItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOutTypeItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOutTypeItem(this);
}
}
public final GopOutTypeItemContext gopOutTypeItem() throws RecognitionException {
GopOutTypeItemContext _localctx = new GopOutTypeItemContext(_ctx, getState());
enterRule(_localctx, 140, RULE_gopOutTypeItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1277);
classIdentifier();
setState(1279);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1278);
gopOutTypeList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopDetailContext extends ParserRuleContext {
public List gopConfig() {
return getRuleContexts(GopConfigContext.class);
}
public GopConfigContext gopConfig(int i) {
return getRuleContext(GopConfigContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopDetailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopDetail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopDetail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopDetail(this);
}
}
public final GopDetailContext gopDetail() throws RecognitionException {
GopDetailContext _localctx = new GopDetailContext(_ctx, getState());
enterRule(_localctx, 142, RULE_gopDetail);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1281);
gopConfig();
setState(1286);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1282);
match(COMMA);
setState(1283);
gopConfig();
}
}
}
setState(1288);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopConfigContext extends ParserRuleContext {
public Token n;
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public SelectExprContext selectExpr() {
return getRuleContext(SelectExprContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public JsonobjectContext jsonobject() {
return getRuleContext(JsonobjectContext.class,0);
}
public JsonarrayContext jsonarray() {
return getRuleContext(JsonarrayContext.class,0);
}
public GopConfigContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopConfig; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopConfig(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopConfig(this);
}
}
public final GopConfigContext gopConfig() throws RecognitionException {
GopConfigContext _localctx = new GopConfigContext(_ctx, getState());
enterRule(_localctx, 144, RULE_gopConfig);
int _la;
try {
setState(1302);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(1289);
match(SELECT);
setState(1290);
_la = _input.LA(1);
if ( !(_la==EQUALS || _la==COLON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1291);
match(LPAREN);
setState(1292);
selectExpr();
setState(1293);
match(RPAREN);
}
break;
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1295);
((GopConfigContext)_localctx).n = match(IDENT);
setState(1296);
_la = _input.LA(1);
if ( !(_la==EQUALS || _la==COLON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1297);
expression();
}
break;
case 2:
{
setState(1298);
jsonobject();
}
break;
case 3:
{
setState(1299);
jsonarray();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextExprContext extends ParserRuleContext {
public Token name;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode CONTEXT() { return getToken(EsperEPL2GrammarParser.CONTEXT, 0); }
public CreateContextDetailContext createContextDetail() {
return getRuleContext(CreateContextDetailContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CreateContextExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextExpr(this);
}
}
public final CreateContextExprContext createContextExpr() throws RecognitionException {
CreateContextExprContext _localctx = new CreateContextExprContext(_ctx, getState());
enterRule(_localctx, 146, RULE_createContextExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1304);
match(CREATE);
setState(1305);
match(CONTEXT);
setState(1306);
((CreateContextExprContext)_localctx).name = match(IDENT);
setState(1308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1307);
match(AS);
}
}
setState(1310);
createContextDetail();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateExpressionExprContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public ExpressionDeclContext expressionDecl() {
return getRuleContext(ExpressionDeclContext.class,0);
}
public CreateExpressionExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createExpressionExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateExpressionExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateExpressionExpr(this);
}
}
public final CreateExpressionExprContext createExpressionExpr() throws RecognitionException {
CreateExpressionExprContext _localctx = new CreateExpressionExprContext(_ctx, getState());
enterRule(_localctx, 148, RULE_createExpressionExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1312);
match(CREATE);
setState(1313);
expressionDecl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateClassExprContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public ClassDeclContext classDecl() {
return getRuleContext(ClassDeclContext.class,0);
}
public CreateClassExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createClassExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateClassExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateClassExpr(this);
}
}
public final CreateClassExprContext createClassExpr() throws RecognitionException {
CreateClassExprContext _localctx = new CreateClassExprContext(_ctx, getState());
enterRule(_localctx, 150, RULE_createClassExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1315);
match(CREATE);
setState(1316);
classDecl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextDetailContext extends ParserRuleContext {
public CreateContextChoiceContext createContextChoice() {
return getRuleContext(CreateContextChoiceContext.class,0);
}
public List contextContextNested() {
return getRuleContexts(ContextContextNestedContext.class);
}
public ContextContextNestedContext contextContextNested(int i) {
return getRuleContext(ContextContextNestedContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateContextDetailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextDetail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextDetail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextDetail(this);
}
}
public final CreateContextDetailContext createContextDetail() throws RecognitionException {
CreateContextDetailContext _localctx = new CreateContextDetailContext(_ctx, getState());
enterRule(_localctx, 152, RULE_createContextDetail);
int _la;
try {
setState(1329);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COALESCE:
case GROUP:
case PARTITION:
case START:
case INITIATED:
enterOuterAlt(_localctx, 1);
{
setState(1318);
createContextChoice();
}
break;
case CONTEXT:
enterOuterAlt(_localctx, 2);
{
setState(1319);
contextContextNested();
setState(1320);
match(COMMA);
setState(1321);
contextContextNested();
setState(1326);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1322);
match(COMMA);
setState(1323);
contextContextNested();
}
}
setState(1328);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContextContextNestedContext extends ParserRuleContext {
public Token name;
public TerminalNode CONTEXT() { return getToken(EsperEPL2GrammarParser.CONTEXT, 0); }
public CreateContextChoiceContext createContextChoice() {
return getRuleContext(CreateContextChoiceContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public ContextContextNestedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contextContextNested; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterContextContextNested(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitContextContextNested(this);
}
}
public final ContextContextNestedContext contextContextNested() throws RecognitionException {
ContextContextNestedContext _localctx = new ContextContextNestedContext(_ctx, getState());
enterRule(_localctx, 154, RULE_contextContextNested);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1331);
match(CONTEXT);
setState(1332);
((ContextContextNestedContext)_localctx).name = match(IDENT);
setState(1334);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1333);
match(AS);
}
}
setState(1336);
createContextChoice();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextChoiceContext extends ParserRuleContext {
public Token i;
public CreateContextRangePointContext r1;
public CreateContextRangePointContext r2;
public Token g;
public Token p;
public TerminalNode START() { return getToken(EsperEPL2GrammarParser.START, 0); }
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List createContextRangePoint() {
return getRuleContexts(CreateContextRangePointContext.class);
}
public CreateContextRangePointContext createContextRangePoint(int i) {
return getRuleContext(CreateContextRangePointContext.class,i);
}
public TerminalNode END() { return getToken(EsperEPL2GrammarParser.END, 0); }
public TerminalNode INITIATED() { return getToken(EsperEPL2GrammarParser.INITIATED, 0); }
public List BY() { return getTokens(EsperEPL2GrammarParser.BY); }
public TerminalNode BY(int i) {
return getToken(EsperEPL2GrammarParser.BY, i);
}
public CreateContextDistinctContext createContextDistinct() {
return getRuleContext(CreateContextDistinctContext.class,0);
}
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public TerminalNode PARTITION() { return getToken(EsperEPL2GrammarParser.PARTITION, 0); }
public List createContextPartitionItem() {
return getRuleContexts(CreateContextPartitionItemContext.class);
}
public CreateContextPartitionItemContext createContextPartitionItem(int i) {
return getRuleContext(CreateContextPartitionItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateContextPartitionInitContext createContextPartitionInit() {
return getRuleContext(CreateContextPartitionInitContext.class,0);
}
public CreateContextPartitionTermContext createContextPartitionTerm() {
return getRuleContext(CreateContextPartitionTermContext.class,0);
}
public List createContextGroupItem() {
return getRuleContexts(CreateContextGroupItemContext.class);
}
public CreateContextGroupItemContext createContextGroupItem(int i) {
return getRuleContext(CreateContextGroupItemContext.class,i);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public TerminalNode COALESCE() { return getToken(EsperEPL2GrammarParser.COALESCE, 0); }
public List createContextCoalesceItem() {
return getRuleContexts(CreateContextCoalesceItemContext.class);
}
public CreateContextCoalesceItemContext createContextCoalesceItem(int i) {
return getRuleContext(CreateContextCoalesceItemContext.class,i);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public CreateContextChoiceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextChoice; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextChoice(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextChoice(this);
}
}
public final CreateContextChoiceContext createContextChoice() throws RecognitionException {
CreateContextChoiceContext _localctx = new CreateContextChoiceContext(_ctx, getState());
enterRule(_localctx, 156, RULE_createContextChoice);
int _la;
try {
int _alt;
setState(1414);
_errHandler.sync(this);
switch (_input.LA(1)) {
case START:
enterOuterAlt(_localctx, 1);
{
setState(1338);
match(START);
setState(1342);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(1339);
match(ATCHAR);
setState(1340);
((CreateContextChoiceContext)_localctx).i = match(IDENT);
}
break;
case EVENTS:
case PATTERN:
case AFTER:
case LPAREN:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1341);
((CreateContextChoiceContext)_localctx).r1 = createContextRangePoint();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==END) {
{
setState(1344);
match(END);
setState(1345);
((CreateContextChoiceContext)_localctx).r2 = createContextRangePoint();
}
}
}
break;
case INITIATED:
enterOuterAlt(_localctx, 2);
{
setState(1348);
match(INITIATED);
setState(1350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1349);
match(BY);
}
}
setState(1353);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1352);
createContextDistinct();
}
}
setState(1358);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1355);
match(ATCHAR);
setState(1356);
((CreateContextChoiceContext)_localctx).i = match(IDENT);
setState(1357);
match(AND_EXPR);
}
}
setState(1360);
((CreateContextChoiceContext)_localctx).r1 = createContextRangePoint();
setState(1366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TERMINATED) {
{
setState(1361);
match(TERMINATED);
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1362);
match(BY);
}
}
setState(1365);
((CreateContextChoiceContext)_localctx).r2 = createContextRangePoint();
}
}
}
break;
case PARTITION:
enterOuterAlt(_localctx, 3);
{
setState(1368);
match(PARTITION);
setState(1370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1369);
match(BY);
}
}
setState(1372);
createContextPartitionItem();
setState(1377);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1373);
match(COMMA);
setState(1374);
createContextPartitionItem();
}
}
}
setState(1379);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
}
setState(1381);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIATED) {
{
setState(1380);
createContextPartitionInit();
}
}
setState(1384);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TERMINATED) {
{
setState(1383);
createContextPartitionTerm();
}
}
}
break;
case GROUP:
enterOuterAlt(_localctx, 4);
{
setState(1386);
createContextGroupItem();
setState(1391);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1387);
match(COMMA);
setState(1388);
createContextGroupItem();
}
}
setState(1393);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1394);
match(FROM);
setState(1395);
eventFilterExpression();
}
break;
case COALESCE:
enterOuterAlt(_localctx, 5);
{
setState(1397);
match(COALESCE);
setState(1399);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1398);
match(BY);
}
}
setState(1401);
createContextCoalesceItem();
setState(1406);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1402);
match(COMMA);
setState(1403);
createContextCoalesceItem();
}
}
setState(1408);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1409);
((CreateContextChoiceContext)_localctx).g = match(IDENT);
setState(1410);
number();
setState(1412);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1411);
((CreateContextChoiceContext)_localctx).p = match(IDENT);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextDistinctContext extends ParserRuleContext {
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public CreateContextDistinctContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextDistinct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextDistinct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextDistinct(this);
}
}
public final CreateContextDistinctContext createContextDistinct() throws RecognitionException {
CreateContextDistinctContext _localctx = new CreateContextDistinctContext(_ctx, getState());
enterRule(_localctx, 158, RULE_createContextDistinct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1416);
match(DISTINCT);
setState(1417);
match(LPAREN);
setState(1419);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1418);
expressionList();
}
}
setState(1421);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextRangePointContext extends ParserRuleContext {
public Token i;
public CreateContextFilterContext createContextFilter() {
return getRuleContext(CreateContextFilterContext.class,0);
}
public PatternInclusionExpressionContext patternInclusionExpression() {
return getRuleContext(PatternInclusionExpressionContext.class,0);
}
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CrontabLimitParameterSetListContext crontabLimitParameterSetList() {
return getRuleContext(CrontabLimitParameterSetListContext.class,0);
}
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public TimePeriodContext timePeriod() {
return getRuleContext(TimePeriodContext.class,0);
}
public CreateContextRangePointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextRangePoint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextRangePoint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextRangePoint(this);
}
}
public final CreateContextRangePointContext createContextRangePoint() throws RecognitionException {
CreateContextRangePointContext _localctx = new CreateContextRangePointContext(_ctx, getState());
enterRule(_localctx, 160, RULE_createContextRangePoint);
int _la;
try {
setState(1438);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(1423);
createContextFilter();
}
break;
case PATTERN:
enterOuterAlt(_localctx, 2);
{
setState(1424);
patternInclusionExpression();
setState(1427);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1425);
match(ATCHAR);
setState(1426);
((CreateContextRangePointContext)_localctx).i = match(IDENT);
}
}
setState(1433);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
case 1:
{
setState(1430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1429);
match(AS);
}
}
setState(1432);
keywordAllowedIdent();
}
break;
}
}
break;
case LPAREN:
enterOuterAlt(_localctx, 3);
{
setState(1435);
crontabLimitParameterSetList();
}
break;
case AFTER:
enterOuterAlt(_localctx, 4);
{
setState(1436);
match(AFTER);
setState(1437);
timePeriod();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextFilterContext extends ParserRuleContext {
public Token i;
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CreateContextFilterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextFilter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextFilter(this);
}
}
public final CreateContextFilterContext createContextFilter() throws RecognitionException {
CreateContextFilterContext _localctx = new CreateContextFilterContext(_ctx, getState());
enterRule(_localctx, 162, RULE_createContextFilter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1440);
eventFilterExpression();
setState(1445);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENT) {
{
setState(1442);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1441);
match(AS);
}
}
setState(1444);
((CreateContextFilterContext)_localctx).i = match(IDENT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextPartitionItemContext extends ParserRuleContext {
public List chainable() {
return getRuleContexts(ChainableContext.class);
}
public ChainableContext chainable(int i) {
return getRuleContext(ChainableContext.class,i);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CreateContextPartitionItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextPartitionItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextPartitionItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextPartitionItem(this);
}
}
public final CreateContextPartitionItemContext createContextPartitionItem() throws RecognitionException {
CreateContextPartitionItemContext _localctx = new CreateContextPartitionItemContext(_ctx, getState());
enterRule(_localctx, 164, RULE_createContextPartitionItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1447);
chainable();
setState(1452);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR || _la==COMMA) {
{
{
setState(1448);
_la = _input.LA(1);
if ( !(_la==AND_EXPR || _la==COMMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1449);
chainable();
}
}
setState(1454);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1455);
match(FROM);
setState(1456);
eventFilterExpression();
setState(1461);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1458);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1457);
match(AS);
}
}
setState(1460);
keywordAllowedIdent();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextCoalesceItemContext extends ParserRuleContext {
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public CreateContextCoalesceItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextCoalesceItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextCoalesceItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextCoalesceItem(this);
}
}
public final CreateContextCoalesceItemContext createContextCoalesceItem() throws RecognitionException {
CreateContextCoalesceItemContext _localctx = new CreateContextCoalesceItemContext(_ctx, getState());
enterRule(_localctx, 166, RULE_createContextCoalesceItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1463);
chainable();
setState(1464);
match(FROM);
setState(1465);
eventFilterExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextGroupItemContext extends ParserRuleContext {
public Token i;
public TerminalNode GROUP() { return getToken(EsperEPL2GrammarParser.GROUP, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public CreateContextGroupItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextGroupItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextGroupItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextGroupItem(this);
}
}
public final CreateContextGroupItemContext createContextGroupItem() throws RecognitionException {
CreateContextGroupItemContext _localctx = new CreateContextGroupItemContext(_ctx, getState());
enterRule(_localctx, 168, RULE_createContextGroupItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1467);
match(GROUP);
setState(1469);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1468);
match(BY);
}
}
setState(1471);
expression();
setState(1472);
match(AS);
setState(1473);
((CreateContextGroupItemContext)_localctx).i = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextPartitionInitContext extends ParserRuleContext {
public TerminalNode INITIATED() { return getToken(EsperEPL2GrammarParser.INITIATED, 0); }
public List createContextFilter() {
return getRuleContexts(CreateContextFilterContext.class);
}
public CreateContextFilterContext createContextFilter(int i) {
return getRuleContext(CreateContextFilterContext.class,i);
}
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateContextPartitionInitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextPartitionInit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextPartitionInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextPartitionInit(this);
}
}
public final CreateContextPartitionInitContext createContextPartitionInit() throws RecognitionException {
CreateContextPartitionInitContext _localctx = new CreateContextPartitionInitContext(_ctx, getState());
enterRule(_localctx, 170, RULE_createContextPartitionInit);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1475);
match(INITIATED);
setState(1477);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1476);
match(BY);
}
}
setState(1479);
createContextFilter();
setState(1484);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1480);
match(COMMA);
setState(1481);
createContextFilter();
}
}
}
setState(1486);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextPartitionTermContext extends ParserRuleContext {
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public CreateContextRangePointContext createContextRangePoint() {
return getRuleContext(CreateContextRangePointContext.class,0);
}
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public CreateContextPartitionTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextPartitionTerm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextPartitionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextPartitionTerm(this);
}
}
public final CreateContextPartitionTermContext createContextPartitionTerm() throws RecognitionException {
CreateContextPartitionTermContext _localctx = new CreateContextPartitionTermContext(_ctx, getState());
enterRule(_localctx, 172, RULE_createContextPartitionTerm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1487);
match(TERMINATED);
setState(1489);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1488);
match(BY);
}
}
setState(1491);
createContextRangePoint();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSchemaQualContext extends ParserRuleContext {
public Token i;
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CreateSchemaQualContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSchemaQual; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSchemaQual(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSchemaQual(this);
}
}
public final CreateSchemaQualContext createSchemaQual() throws RecognitionException {
CreateSchemaQualContext _localctx = new CreateSchemaQualContext(_ctx, getState());
enterRule(_localctx, 174, RULE_createSchemaQual);
try {
enterOuterAlt(_localctx, 1);
{
setState(1493);
((CreateSchemaQualContext)_localctx).i = match(IDENT);
setState(1494);
columnList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariantListContext extends ParserRuleContext {
public List variantListElement() {
return getRuleContexts(VariantListElementContext.class);
}
public VariantListElementContext variantListElement(int i) {
return getRuleContext(VariantListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public VariantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterVariantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitVariantList(this);
}
}
public final VariantListContext variantList() throws RecognitionException {
VariantListContext _localctx = new VariantListContext(_ctx, getState());
enterRule(_localctx, 176, RULE_variantList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1496);
variantListElement();
setState(1501);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,167,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1497);
match(COMMA);
setState(1498);
variantListElement();
}
}
}
setState(1503);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,167,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariantListElementContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public VariantListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterVariantListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitVariantListElement(this);
}
}
public final VariantListElementContext variantListElement() throws RecognitionException {
VariantListElementContext _localctx = new VariantListElementContext(_ctx, getState());
enterRule(_localctx, 178, RULE_variantListElement);
try {
setState(1506);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1504);
match(STAR);
}
break;
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1505);
classIdentifierWithDimensions();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntoTableExprContext extends ParserRuleContext {
public Token i;
public TerminalNode TABLE() { return getToken(EsperEPL2GrammarParser.TABLE, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public IntoTableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intoTableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterIntoTableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitIntoTableExpr(this);
}
}
public final IntoTableExprContext intoTableExpr() throws RecognitionException {
IntoTableExprContext _localctx = new IntoTableExprContext(_ctx, getState());
enterRule(_localctx, 180, RULE_intoTableExpr);
paraphrases.push("into-table clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1508);
match(TABLE);
setState(1509);
((IntoTableExprContext)_localctx).i = match(IDENT);
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertIntoExprContext extends ParserRuleContext {
public Token i;
public Token r;
public Token ir;
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public InsertIntoEventPrecedenceContext insertIntoEventPrecedence() {
return getRuleContext(InsertIntoEventPrecedenceContext.class,0);
}
public TerminalNode ISTREAM() { return getToken(EsperEPL2GrammarParser.ISTREAM, 0); }
public TerminalNode RSTREAM() { return getToken(EsperEPL2GrammarParser.RSTREAM, 0); }
public TerminalNode IRSTREAM() { return getToken(EsperEPL2GrammarParser.IRSTREAM, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public InsertIntoExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertIntoExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterInsertIntoExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitInsertIntoExpr(this);
}
}
public final InsertIntoExprContext insertIntoExpr() throws RecognitionException {
InsertIntoExprContext _localctx = new InsertIntoExprContext(_ctx, getState());
enterRule(_localctx, 182, RULE_insertIntoExpr);
paraphrases.push("insert-into clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1514);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ISTREAM:
{
setState(1511);
((InsertIntoExprContext)_localctx).i = match(ISTREAM);
}
break;
case RSTREAM:
{
setState(1512);
((InsertIntoExprContext)_localctx).r = match(RSTREAM);
}
break;
case IRSTREAM:
{
setState(1513);
((InsertIntoExprContext)_localctx).ir = match(IRSTREAM);
}
break;
case INTO:
break;
default:
break;
}
setState(1516);
match(INTO);
setState(1517);
classIdentifier();
setState(1523);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1518);
match(LPAREN);
setState(1520);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1519);
columnList();
}
}
setState(1522);
match(RPAREN);
}
}
setState(1526);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EVENTPRECEDENCE) {
{
setState(1525);
insertIntoEventPrecedence();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertIntoEventPrecedenceContext extends ParserRuleContext {
public TerminalNode EVENTPRECEDENCE() { return getToken(EsperEPL2GrammarParser.EVENTPRECEDENCE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public InsertIntoEventPrecedenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertIntoEventPrecedence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterInsertIntoEventPrecedence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitInsertIntoEventPrecedence(this);
}
}
public final InsertIntoEventPrecedenceContext insertIntoEventPrecedence() throws RecognitionException {
InsertIntoEventPrecedenceContext _localctx = new InsertIntoEventPrecedenceContext(_ctx, getState());
enterRule(_localctx, 184, RULE_insertIntoEventPrecedence);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1528);
match(EVENTPRECEDENCE);
setState(1529);
match(LPAREN);
setState(1530);
expression();
setState(1531);
match(RPAREN);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ColumnListContext extends ParserRuleContext {
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitColumnList(this);
}
}
public final ColumnListContext columnList() throws RecognitionException {
ColumnListContext _localctx = new ColumnListContext(_ctx, getState());
enterRule(_localctx, 186, RULE_columnList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1533);
match(IDENT);
setState(1538);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,173,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1534);
match(COMMA);
setState(1535);
match(IDENT);
}
}
}
setState(1540);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,173,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ColumnListKeywordAllowedContext extends ParserRuleContext {
public List keywordAllowedIdent() {
return getRuleContexts(KeywordAllowedIdentContext.class);
}
public KeywordAllowedIdentContext keywordAllowedIdent(int i) {
return getRuleContext(KeywordAllowedIdentContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ColumnListKeywordAllowedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnListKeywordAllowed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterColumnListKeywordAllowed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitColumnListKeywordAllowed(this);
}
}
public final ColumnListKeywordAllowedContext columnListKeywordAllowed() throws RecognitionException {
ColumnListKeywordAllowedContext _localctx = new ColumnListKeywordAllowedContext(_ctx, getState());
enterRule(_localctx, 188, RULE_columnListKeywordAllowed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1541);
keywordAllowedIdent();
setState(1546);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1542);
match(COMMA);
setState(1543);
keywordAllowedIdent();
}
}
setState(1548);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromClauseContext extends ParserRuleContext {
public StreamExpressionContext streamExpression() {
return getRuleContext(StreamExpressionContext.class,0);
}
public RegularJoinContext regularJoin() {
return getRuleContext(RegularJoinContext.class,0);
}
public OuterJoinListContext outerJoinList() {
return getRuleContext(OuterJoinListContext.class,0);
}
public FromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFromClause(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 190, RULE_fromClause);
paraphrases.push("from clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1549);
streamExpression();
setState(1552);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EOF:
case WHERE:
case GROUP:
case HAVING:
case OUTPUT:
case ORDER:
case ROW_LIMIT_EXPR:
case MATCH_RECOGNIZE:
case FOR:
case RPAREN:
case COMMA:
{
setState(1550);
regularJoin();
}
break;
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
{
setState(1551);
outerJoinList();
}
break;
default:
throw new NoViableAltException(this);
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegularJoinContext extends ParserRuleContext {
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List streamExpression() {
return getRuleContexts(StreamExpressionContext.class);
}
public StreamExpressionContext streamExpression(int i) {
return getRuleContext(StreamExpressionContext.class,i);
}
public RegularJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regularJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRegularJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRegularJoin(this);
}
}
public final RegularJoinContext regularJoin() throws RecognitionException {
RegularJoinContext _localctx = new RegularJoinContext(_ctx, getState());
enterRule(_localctx, 192, RULE_regularJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1558);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1554);
match(COMMA);
setState(1555);
streamExpression();
}
}
setState(1560);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinListContext extends ParserRuleContext {
public List outerJoin() {
return getRuleContexts(OuterJoinContext.class);
}
public OuterJoinContext outerJoin(int i) {
return getRuleContext(OuterJoinContext.class,i);
}
public OuterJoinListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoinList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOuterJoinList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOuterJoinList(this);
}
}
public final OuterJoinListContext outerJoinList() throws RecognitionException {
OuterJoinListContext _localctx = new OuterJoinListContext(_ctx, getState());
enterRule(_localctx, 194, RULE_outerJoinList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1561);
outerJoin();
setState(1565);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INNER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL))) != 0)) {
{
{
setState(1562);
outerJoin();
}
}
setState(1567);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinContext extends ParserRuleContext {
public Token tl;
public Token tr;
public Token tf;
public Token i;
public TerminalNode JOIN() { return getToken(EsperEPL2GrammarParser.JOIN, 0); }
public StreamExpressionContext streamExpression() {
return getRuleContext(StreamExpressionContext.class,0);
}
public OuterJoinIdentContext outerJoinIdent() {
return getRuleContext(OuterJoinIdentContext.class,0);
}
public TerminalNode OUTER() { return getToken(EsperEPL2GrammarParser.OUTER, 0); }
public TerminalNode INNER() { return getToken(EsperEPL2GrammarParser.INNER, 0); }
public TerminalNode LEFT() { return getToken(EsperEPL2GrammarParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(EsperEPL2GrammarParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(EsperEPL2GrammarParser.FULL, 0); }
public OuterJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOuterJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOuterJoin(this);
}
}
public final OuterJoinContext outerJoin() throws RecognitionException {
OuterJoinContext _localctx = new OuterJoinContext(_ctx, getState());
enterRule(_localctx, 196, RULE_outerJoin);
paraphrases.push("outer join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1577);
_errHandler.sync(this);
switch (_input.LA(1)) {
case JOIN:
case LEFT:
case RIGHT:
case FULL:
{
setState(1574);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEFT) | (1L << RIGHT) | (1L << FULL))) != 0)) {
{
setState(1571);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LEFT:
{
setState(1568);
((OuterJoinContext)_localctx).tl = match(LEFT);
}
break;
case RIGHT:
{
setState(1569);
((OuterJoinContext)_localctx).tr = match(RIGHT);
}
break;
case FULL:
{
setState(1570);
((OuterJoinContext)_localctx).tf = match(FULL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1573);
match(OUTER);
}
}
}
break;
case INNER:
{
{
setState(1576);
((OuterJoinContext)_localctx).i = match(INNER);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1579);
match(JOIN);
setState(1580);
streamExpression();
setState(1582);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1581);
outerJoinIdent();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinIdentContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(EsperEPL2GrammarParser.ON, 0); }
public List outerJoinIdentPair() {
return getRuleContexts(OuterJoinIdentPairContext.class);
}
public OuterJoinIdentPairContext outerJoinIdentPair(int i) {
return getRuleContext(OuterJoinIdentPairContext.class,i);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public OuterJoinIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoinIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOuterJoinIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOuterJoinIdent(this);
}
}
public final OuterJoinIdentContext outerJoinIdent() throws RecognitionException {
OuterJoinIdentContext _localctx = new OuterJoinIdentContext(_ctx, getState());
enterRule(_localctx, 198, RULE_outerJoinIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1584);
match(ON);
setState(1585);
outerJoinIdentPair();
setState(1590);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR) {
{
{
setState(1586);
match(AND_EXPR);
setState(1587);
outerJoinIdentPair();
}
}
setState(1592);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinIdentPairContext extends ParserRuleContext {
public List chainable() {
return getRuleContexts(ChainableContext.class);
}
public ChainableContext chainable(int i) {
return getRuleContext(ChainableContext.class,i);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public OuterJoinIdentPairContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoinIdentPair; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOuterJoinIdentPair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOuterJoinIdentPair(this);
}
}
public final OuterJoinIdentPairContext outerJoinIdentPair() throws RecognitionException {
OuterJoinIdentPairContext _localctx = new OuterJoinIdentPairContext(_ctx, getState());
enterRule(_localctx, 200, RULE_outerJoinIdentPair);
try {
enterOuterAlt(_localctx, 1);
{
setState(1593);
chainable();
setState(1594);
match(EQUALS);
setState(1595);
chainable();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhereClauseContext extends ParserRuleContext {
public EvalOrExpressionContext evalOrExpression() {
return getRuleContext(EvalOrExpressionContext.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 EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitWhereClause(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 202, RULE_whereClause);
paraphrases.push("where clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1597);
evalOrExpression();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectClauseContext extends ParserRuleContext {
public Token s;
public Token d;
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode RSTREAM() { return getToken(EsperEPL2GrammarParser.RSTREAM, 0); }
public TerminalNode ISTREAM() { return getToken(EsperEPL2GrammarParser.ISTREAM, 0); }
public TerminalNode IRSTREAM() { return getToken(EsperEPL2GrammarParser.IRSTREAM, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public SelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectClause(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 204, RULE_selectClause);
paraphrases.push("select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1602);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
case 1:
{
setState(1599);
((SelectClauseContext)_localctx).s = match(RSTREAM);
}
break;
case 2:
{
setState(1600);
((SelectClauseContext)_localctx).s = match(ISTREAM);
}
break;
case 3:
{
setState(1601);
((SelectClauseContext)_localctx).s = match(IRSTREAM);
}
break;
}
setState(1605);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1604);
((SelectClauseContext)_localctx).d = match(DISTINCT);
}
}
setState(1607);
selectionList();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectionListContext extends ParserRuleContext {
public List selectionListElement() {
return getRuleContexts(SelectionListElementContext.class);
}
public SelectionListElementContext selectionListElement(int i) {
return getRuleContext(SelectionListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public SelectionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectionList(this);
}
}
public final SelectionListContext selectionList() throws RecognitionException {
SelectionListContext _localctx = new SelectionListContext(_ctx, getState());
enterRule(_localctx, 206, RULE_selectionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1609);
selectionListElement();
setState(1614);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1610);
match(COMMA);
setState(1611);
selectionListElement();
}
}
setState(1616);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectionListElementContext extends ParserRuleContext {
public Token s;
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public StreamSelectorContext streamSelector() {
return getRuleContext(StreamSelectorContext.class,0);
}
public SelectionListElementExprContext selectionListElementExpr() {
return getRuleContext(SelectionListElementExprContext.class,0);
}
public SelectionListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectionListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectionListElement(this);
}
}
public final SelectionListElementContext selectionListElement() throws RecognitionException {
SelectionListElementContext _localctx = new SelectionListElementContext(_ctx, getState());
enterRule(_localctx, 208, RULE_selectionListElement);
try {
setState(1620);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1617);
((SelectionListElementContext)_localctx).s = match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1618);
streamSelector();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1619);
selectionListElementExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectionListElementExprContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SelectionListElementAnnoContext selectionListElementAnno() {
return getRuleContext(SelectionListElementAnnoContext.class,0);
}
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public SelectionListElementExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionListElementExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectionListElementExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectionListElementExpr(this);
}
}
public final SelectionListElementExprContext selectionListElementExpr() throws RecognitionException {
SelectionListElementExprContext _localctx = new SelectionListElementExprContext(_ctx, getState());
enterRule(_localctx, 210, RULE_selectionListElementExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1622);
expression();
setState(1624);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1623);
selectionListElementAnno();
}
}
setState(1630);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
{
setState(1627);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1626);
match(AS);
}
}
setState(1629);
keywordAllowedIdent();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectionListElementAnnoContext extends ParserRuleContext {
public Token i;
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public SelectionListElementAnnoContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionListElementAnno; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectionListElementAnno(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectionListElementAnno(this);
}
}
public final SelectionListElementAnnoContext selectionListElementAnno() throws RecognitionException {
SelectionListElementAnnoContext _localctx = new SelectionListElementAnnoContext(_ctx, getState());
enterRule(_localctx, 212, RULE_selectionListElementAnno);
try {
enterOuterAlt(_localctx, 1);
{
setState(1632);
match(ATCHAR);
setState(1633);
((SelectionListElementAnnoContext)_localctx).i = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamSelectorContext extends ParserRuleContext {
public Token s;
public Token i;
public TerminalNode DOT() { return getToken(EsperEPL2GrammarParser.DOT, 0); }
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public StreamSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_streamSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStreamSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStreamSelector(this);
}
}
public final StreamSelectorContext streamSelector() throws RecognitionException {
StreamSelectorContext _localctx = new StreamSelectorContext(_ctx, getState());
enterRule(_localctx, 214, RULE_streamSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1635);
((StreamSelectorContext)_localctx).s = match(IDENT);
setState(1636);
match(DOT);
setState(1637);
match(STAR);
setState(1640);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1638);
match(AS);
setState(1639);
((StreamSelectorContext)_localctx).i = match(IDENT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamExpressionContext extends ParserRuleContext {
public Token u;
public Token ru;
public Token ri;
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public PatternInclusionExpressionContext patternInclusionExpression() {
return getRuleContext(PatternInclusionExpressionContext.class,0);
}
public DatabaseJoinExpressionContext databaseJoinExpression() {
return getRuleContext(DatabaseJoinExpressionContext.class,0);
}
public MethodJoinExpressionContext methodJoinExpression() {
return getRuleContext(MethodJoinExpressionContext.class,0);
}
public ViewExpressionsContext viewExpressions() {
return getRuleContext(ViewExpressionsContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode UNIDIRECTIONAL() { return getToken(EsperEPL2GrammarParser.UNIDIRECTIONAL, 0); }
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public StreamExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_streamExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStreamExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStreamExpression(this);
}
}
public final StreamExpressionContext streamExpression() throws RecognitionException {
StreamExpressionContext _localctx = new StreamExpressionContext(_ctx, getState());
enterRule(_localctx, 216, RULE_streamExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1646);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
case 1:
{
setState(1642);
eventFilterExpression();
}
break;
case 2:
{
setState(1643);
patternInclusionExpression();
}
break;
case 3:
{
setState(1644);
databaseJoinExpression();
}
break;
case 4:
{
setState(1645);
methodJoinExpression();
}
break;
}
setState(1649);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(1648);
viewExpressions();
}
}
setState(1654);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(1651);
match(AS);
setState(1652);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1653);
identOrTicked();
}
break;
case EOF:
case WHERE:
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case ON:
case GROUP:
case HAVING:
case OUTPUT:
case ORDER:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case ROW_LIMIT_EXPR:
case MATCH_RECOGNIZE:
case FOR:
case RPAREN:
case COMMA:
break;
default:
break;
}
setState(1657);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNIDIRECTIONAL) {
{
setState(1656);
((StreamExpressionContext)_localctx).u = match(UNIDIRECTIONAL);
}
}
setState(1661);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(1659);
((StreamExpressionContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(1660);
((StreamExpressionContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case EOF:
case WHERE:
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case ON:
case GROUP:
case HAVING:
case OUTPUT:
case ORDER:
case ROW_LIMIT_EXPR:
case MATCH_RECOGNIZE:
case FOR:
case RPAREN:
case COMMA:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForExprContext extends ParserRuleContext {
public Token i;
public TerminalNode FOR() { return getToken(EsperEPL2GrammarParser.FOR, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ForExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterForExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitForExpr(this);
}
}
public final ForExprContext forExpr() throws RecognitionException {
ForExprContext _localctx = new ForExprContext(_ctx, getState());
enterRule(_localctx, 218, RULE_forExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1663);
match(FOR);
setState(1664);
((ForExprContext)_localctx).i = match(IDENT);
setState(1670);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1665);
match(LPAREN);
setState(1667);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1666);
expressionList();
}
}
setState(1669);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternInclusionExpressionContext extends ParserRuleContext {
public TerminalNode PATTERN() { return getToken(EsperEPL2GrammarParser.PATTERN, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public PatternExpressionContext patternExpression() {
return getRuleContext(PatternExpressionContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public PatternInclusionExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternInclusionExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPatternInclusionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPatternInclusionExpression(this);
}
}
public final PatternInclusionExpressionContext patternInclusionExpression() throws RecognitionException {
PatternInclusionExpressionContext _localctx = new PatternInclusionExpressionContext(_ctx, getState());
enterRule(_localctx, 220, RULE_patternInclusionExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1672);
match(PATTERN);
setState(1676);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
{
setState(1673);
annotationEnum();
}
}
setState(1678);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1679);
match(LBRACK);
setState(1680);
patternExpression();
setState(1681);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DatabaseJoinExpressionContext extends ParserRuleContext {
public Token i;
public Token s;
public Token s2;
public TerminalNode SQL() { return getToken(EsperEPL2GrammarParser.SQL, 0); }
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public List STRING_LITERAL() { return getTokens(EsperEPL2GrammarParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(EsperEPL2GrammarParser.STRING_LITERAL, i);
}
public List QUOTED_STRING_LITERAL() { return getTokens(EsperEPL2GrammarParser.QUOTED_STRING_LITERAL); }
public TerminalNode QUOTED_STRING_LITERAL(int i) {
return getToken(EsperEPL2GrammarParser.QUOTED_STRING_LITERAL, i);
}
public TerminalNode METADATASQL() { return getToken(EsperEPL2GrammarParser.METADATASQL, 0); }
public DatabaseJoinExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_databaseJoinExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDatabaseJoinExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDatabaseJoinExpression(this);
}
}
public final DatabaseJoinExpressionContext databaseJoinExpression() throws RecognitionException {
DatabaseJoinExpressionContext _localctx = new DatabaseJoinExpressionContext(_ctx, getState());
enterRule(_localctx, 222, RULE_databaseJoinExpression);
paraphrases.push("relational data join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1683);
match(SQL);
setState(1684);
match(COLON);
setState(1685);
((DatabaseJoinExpressionContext)_localctx).i = match(IDENT);
setState(1686);
match(LBRACK);
setState(1689);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(1687);
((DatabaseJoinExpressionContext)_localctx).s = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(1688);
((DatabaseJoinExpressionContext)_localctx).s = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1696);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==METADATASQL) {
{
setState(1691);
match(METADATASQL);
setState(1694);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(1692);
((DatabaseJoinExpressionContext)_localctx).s2 = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(1693);
((DatabaseJoinExpressionContext)_localctx).s2 = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(1698);
match(RBRACK);
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodJoinExpressionContext extends ParserRuleContext {
public Token i;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TypeExpressionAnnotationContext typeExpressionAnnotation() {
return getRuleContext(TypeExpressionAnnotationContext.class,0);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public MethodJoinExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodJoinExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMethodJoinExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMethodJoinExpression(this);
}
}
public final MethodJoinExpressionContext methodJoinExpression() throws RecognitionException {
MethodJoinExpressionContext _localctx = new MethodJoinExpressionContext(_ctx, getState());
enterRule(_localctx, 224, RULE_methodJoinExpression);
paraphrases.push("method invocation join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1700);
((MethodJoinExpressionContext)_localctx).i = match(IDENT);
setState(1701);
match(COLON);
setState(1702);
classIdentifier();
setState(1708);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1703);
match(LPAREN);
setState(1705);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1704);
expressionList();
}
}
setState(1707);
match(RPAREN);
}
}
setState(1711);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1710);
typeExpressionAnnotation();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ViewExpressionsContext extends ParserRuleContext {
public List DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public List viewExpressionWNamespace() {
return getRuleContexts(ViewExpressionWNamespaceContext.class);
}
public ViewExpressionWNamespaceContext viewExpressionWNamespace(int i) {
return getRuleContext(ViewExpressionWNamespaceContext.class,i);
}
public List HASHCHAR() { return getTokens(EsperEPL2GrammarParser.HASHCHAR); }
public TerminalNode HASHCHAR(int i) {
return getToken(EsperEPL2GrammarParser.HASHCHAR, i);
}
public List viewExpressionOptNamespace() {
return getRuleContexts(ViewExpressionOptNamespaceContext.class);
}
public ViewExpressionOptNamespaceContext viewExpressionOptNamespace(int i) {
return getRuleContext(ViewExpressionOptNamespaceContext.class,i);
}
public ViewExpressionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_viewExpressions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterViewExpressions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitViewExpressions(this);
}
}
public final ViewExpressionsContext viewExpressions() throws RecognitionException {
ViewExpressionsContext _localctx = new ViewExpressionsContext(_ctx, getState());
enterRule(_localctx, 226, RULE_viewExpressions);
paraphrases.push("view specifications");
int _la;
try {
setState(1731);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DOT:
enterOuterAlt(_localctx, 1);
{
{
setState(1713);
match(DOT);
setState(1714);
viewExpressionWNamespace();
setState(1719);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1715);
match(DOT);
setState(1716);
viewExpressionWNamespace();
}
}
setState(1721);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case HASHCHAR:
enterOuterAlt(_localctx, 2);
{
{
setState(1722);
match(HASHCHAR);
setState(1723);
viewExpressionOptNamespace();
setState(1728);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==HASHCHAR) {
{
{
setState(1724);
match(HASHCHAR);
setState(1725);
viewExpressionOptNamespace();
}
}
setState(1730);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ViewExpressionWNamespaceContext extends ParserRuleContext {
public Token ns;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public ViewWParametersContext viewWParameters() {
return getRuleContext(ViewWParametersContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ViewExpressionWNamespaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_viewExpressionWNamespace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterViewExpressionWNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitViewExpressionWNamespace(this);
}
}
public final ViewExpressionWNamespaceContext viewExpressionWNamespace() throws RecognitionException {
ViewExpressionWNamespaceContext _localctx = new ViewExpressionWNamespaceContext(_ctx, getState());
enterRule(_localctx, 228, RULE_viewExpressionWNamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1733);
((ViewExpressionWNamespaceContext)_localctx).ns = match(IDENT);
setState(1734);
match(COLON);
setState(1735);
viewWParameters();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ViewExpressionOptNamespaceContext extends ParserRuleContext {
public Token ns;
public ViewWParametersContext viewWParameters() {
return getRuleContext(ViewWParametersContext.class,0);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ViewExpressionOptNamespaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_viewExpressionOptNamespace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterViewExpressionOptNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitViewExpressionOptNamespace(this);
}
}
public final ViewExpressionOptNamespaceContext viewExpressionOptNamespace() throws RecognitionException {
ViewExpressionOptNamespaceContext _localctx = new ViewExpressionOptNamespaceContext(_ctx, getState());
enterRule(_localctx, 230, RULE_viewExpressionOptNamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1739);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
{
setState(1737);
((ViewExpressionOptNamespaceContext)_localctx).ns = match(IDENT);
setState(1738);
match(COLON);
}
break;
}
setState(1741);
viewWParameters();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ViewWParametersContext extends ParserRuleContext {
public Token i;
public Token m;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode MERGE() { return getToken(EsperEPL2GrammarParser.MERGE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionWithTimeListContext expressionWithTimeList() {
return getRuleContext(ExpressionWithTimeListContext.class,0);
}
public ViewWParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_viewWParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterViewWParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitViewWParameters(this);
}
}
public final ViewWParametersContext viewWParameters() throws RecognitionException {
ViewWParametersContext _localctx = new ViewWParametersContext(_ctx, getState());
enterRule(_localctx, 232, RULE_viewWParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1745);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(1743);
((ViewWParametersContext)_localctx).i = match(IDENT);
}
break;
case MERGE:
{
setState(1744);
((ViewWParametersContext)_localctx).m = match(MERGE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1752);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
case 1:
{
setState(1747);
match(LPAREN);
setState(1749);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1748);
expressionWithTimeList();
}
}
setState(1751);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByListExprContext extends ParserRuleContext {
public List groupByListChoice() {
return getRuleContexts(GroupByListChoiceContext.class);
}
public GroupByListChoiceContext groupByListChoice(int i) {
return getRuleContext(GroupByListChoiceContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByListExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByListExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByListExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByListExpr(this);
}
}
public final GroupByListExprContext groupByListExpr() throws RecognitionException {
GroupByListExprContext _localctx = new GroupByListExprContext(_ctx, getState());
enterRule(_localctx, 234, RULE_groupByListExpr);
paraphrases.push("group-by clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1754);
groupByListChoice();
setState(1759);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1755);
match(COMMA);
setState(1756);
groupByListChoice();
}
}
setState(1761);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByListChoiceContext extends ParserRuleContext {
public ExpressionContext e1;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public GroupByCubeOrRollupContext groupByCubeOrRollup() {
return getRuleContext(GroupByCubeOrRollupContext.class,0);
}
public GroupByGroupingSetsContext groupByGroupingSets() {
return getRuleContext(GroupByGroupingSetsContext.class,0);
}
public GroupByListChoiceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByListChoice; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByListChoice(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByListChoice(this);
}
}
public final GroupByListChoiceContext groupByListChoice() throws RecognitionException {
GroupByListChoiceContext _localctx = new GroupByListChoiceContext(_ctx, getState());
enterRule(_localctx, 236, RULE_groupByListChoice);
try {
setState(1765);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1762);
((GroupByListChoiceContext)_localctx).e1 = expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1763);
groupByCubeOrRollup();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1764);
groupByGroupingSets();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByCubeOrRollupContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List groupByCombinableExpr() {
return getRuleContexts(GroupByCombinableExprContext.class);
}
public GroupByCombinableExprContext groupByCombinableExpr(int i) {
return getRuleContext(GroupByCombinableExprContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode CUBE() { return getToken(EsperEPL2GrammarParser.CUBE, 0); }
public TerminalNode ROLLUP() { return getToken(EsperEPL2GrammarParser.ROLLUP, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByCubeOrRollupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByCubeOrRollup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByCubeOrRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByCubeOrRollup(this);
}
}
public final GroupByCubeOrRollupContext groupByCubeOrRollup() throws RecognitionException {
GroupByCubeOrRollupContext _localctx = new GroupByCubeOrRollupContext(_ctx, getState());
enterRule(_localctx, 238, RULE_groupByCubeOrRollup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1767);
_la = _input.LA(1);
if ( !(_la==CUBE || _la==ROLLUP) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1768);
match(LPAREN);
setState(1769);
groupByCombinableExpr();
setState(1774);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1770);
match(COMMA);
setState(1771);
groupByCombinableExpr();
}
}
setState(1776);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1777);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByGroupingSetsContext extends ParserRuleContext {
public TerminalNode GROUPING() { return getToken(EsperEPL2GrammarParser.GROUPING, 0); }
public TerminalNode SETS() { return getToken(EsperEPL2GrammarParser.SETS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List groupBySetsChoice() {
return getRuleContexts(GroupBySetsChoiceContext.class);
}
public GroupBySetsChoiceContext groupBySetsChoice(int i) {
return getRuleContext(GroupBySetsChoiceContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByGroupingSetsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByGroupingSets; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByGroupingSets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByGroupingSets(this);
}
}
public final GroupByGroupingSetsContext groupByGroupingSets() throws RecognitionException {
GroupByGroupingSetsContext _localctx = new GroupByGroupingSetsContext(_ctx, getState());
enterRule(_localctx, 240, RULE_groupByGroupingSets);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1779);
match(GROUPING);
setState(1780);
match(SETS);
setState(1781);
match(LPAREN);
setState(1782);
groupBySetsChoice();
setState(1787);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1783);
match(COMMA);
setState(1784);
groupBySetsChoice();
}
}
setState(1789);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1790);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupBySetsChoiceContext extends ParserRuleContext {
public GroupByCubeOrRollupContext groupByCubeOrRollup() {
return getRuleContext(GroupByCubeOrRollupContext.class,0);
}
public GroupByCombinableExprContext groupByCombinableExpr() {
return getRuleContext(GroupByCombinableExprContext.class,0);
}
public GroupBySetsChoiceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupBySetsChoice; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupBySetsChoice(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupBySetsChoice(this);
}
}
public final GroupBySetsChoiceContext groupBySetsChoice() throws RecognitionException {
GroupBySetsChoiceContext _localctx = new GroupBySetsChoiceContext(_ctx, getState());
enterRule(_localctx, 242, RULE_groupBySetsChoice);
try {
setState(1794);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CUBE:
case ROLLUP:
enterOuterAlt(_localctx, 1);
{
setState(1792);
groupByCubeOrRollup();
}
break;
case WINDOW:
case BETWEEN:
case ESCAPE:
case NOT_EXPR:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case CASE:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case ISTREAM:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PREVIOUSCOUNT:
case PREVIOUSWINDOW:
case PRIOR:
case EXISTS:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case CURRENT_TIMESTAMP:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case NEWKW:
case CONTEXT:
case GROUPING:
case GROUPING_ID:
case QUESTION:
case LPAREN:
case LCURLY:
case PLUS:
case MINUS:
case TICKED_STRING_LITERAL:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IDENT:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 2);
{
setState(1793);
groupByCombinableExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByCombinableExprContext extends ParserRuleContext {
public ExpressionContext e1;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByCombinableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByCombinableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByCombinableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByCombinableExpr(this);
}
}
public final GroupByCombinableExprContext groupByCombinableExpr() throws RecognitionException {
GroupByCombinableExprContext _localctx = new GroupByCombinableExprContext(_ctx, getState());
enterRule(_localctx, 244, RULE_groupByCombinableExpr);
int _la;
try {
setState(1809);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1796);
((GroupByCombinableExprContext)_localctx).e1 = expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1797);
match(LPAREN);
setState(1806);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(1798);
expression();
setState(1803);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1799);
match(COMMA);
setState(1800);
expression();
}
}
setState(1805);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1808);
match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByListExprContext extends ParserRuleContext {
public List orderByListElement() {
return getRuleContexts(OrderByListElementContext.class);
}
public OrderByListElementContext orderByListElement(int i) {
return getRuleContext(OrderByListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public OrderByListExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByListExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOrderByListExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOrderByListExpr(this);
}
}
public final OrderByListExprContext orderByListExpr() throws RecognitionException {
OrderByListExprContext _localctx = new OrderByListExprContext(_ctx, getState());
enterRule(_localctx, 246, RULE_orderByListExpr);
paraphrases.push("order by clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1811);
orderByListElement();
setState(1816);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1812);
match(COMMA);
setState(1813);
orderByListElement();
}
}
setState(1818);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByListElementContext extends ParserRuleContext {
public Token a;
public Token d;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode ASC() { return getToken(EsperEPL2GrammarParser.ASC, 0); }
public TerminalNode DESC() { return getToken(EsperEPL2GrammarParser.DESC, 0); }
public OrderByListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOrderByListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOrderByListElement(this);
}
}
public final OrderByListElementContext orderByListElement() throws RecognitionException {
OrderByListElementContext _localctx = new OrderByListElementContext(_ctx, getState());
enterRule(_localctx, 248, RULE_orderByListElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1819);
expression();
setState(1822);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASC:
{
setState(1820);
((OrderByListElementContext)_localctx).a = match(ASC);
}
break;
case DESC:
{
setState(1821);
((OrderByListElementContext)_localctx).d = match(DESC);
}
break;
case EOF:
case INSERT:
case ROW_LIMIT_EXPR:
case FOR:
case RPAREN:
case COMMA:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public EvalOrExpressionContext evalOrExpression() {
return getRuleContext(EvalOrExpressionContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitHavingClause(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 250, RULE_havingClause);
paraphrases.push("having clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1824);
evalOrExpression();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputLimitContext extends ParserRuleContext {
public Token k;
public Token ev;
public Token i;
public Token e;
public Token at;
public Token wh;
public Token t;
public OutputLimitAfterContext outputLimitAfter() {
return getRuleContext(OutputLimitAfterContext.class,0);
}
public OutputLimitAndTermContext outputLimitAndTerm() {
return getRuleContext(OutputLimitAndTermContext.class,0);
}
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public TerminalNode SNAPSHOT() { return getToken(EsperEPL2GrammarParser.SNAPSHOT, 0); }
public CrontabLimitParameterSetContext crontabLimitParameterSet() {
return getRuleContext(CrontabLimitParameterSetContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public TerminalNode EVERY_EXPR() { return getToken(EsperEPL2GrammarParser.EVERY_EXPR, 0); }
public TerminalNode AT() { return getToken(EsperEPL2GrammarParser.AT, 0); }
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TimePeriodContext timePeriod() {
return getRuleContext(TimePeriodContext.class,0);
}
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public OnSetExprContext onSetExpr() {
return getRuleContext(OnSetExprContext.class,0);
}
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode EVENTS() { return getToken(EsperEPL2GrammarParser.EVENTS, 0); }
public OutputLimitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputLimit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOutputLimit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOutputLimit(this);
}
}
public final OutputLimitContext outputLimit() throws RecognitionException {
OutputLimitContext _localctx = new OutputLimitContext(_ctx, getState());
enterRule(_localctx, 252, RULE_outputLimit);
paraphrases.push("output rate clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1827);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER) {
{
setState(1826);
outputLimitAfter();
}
}
setState(1833);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
{
setState(1829);
((OutputLimitContext)_localctx).k = match(ALL);
}
break;
case FIRST:
{
setState(1830);
((OutputLimitContext)_localctx).k = match(FIRST);
}
break;
case LAST:
{
setState(1831);
((OutputLimitContext)_localctx).k = match(LAST);
}
break;
case SNAPSHOT:
{
setState(1832);
((OutputLimitContext)_localctx).k = match(SNAPSHOT);
}
break;
case EOF:
case AND_EXPR:
case EVERY_EXPR:
case WHEN:
case ORDER:
case AT:
case ROW_LIMIT_EXPR:
case FOR:
case RPAREN:
break;
default:
break;
}
setState(1863);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) {
case 1:
{
{
setState(1835);
((OutputLimitContext)_localctx).ev = match(EVERY_EXPR);
setState(1842);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
case 1:
{
setState(1836);
timePeriod();
}
break;
case 2:
{
setState(1839);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1837);
number();
}
break;
case IDENT:
{
setState(1838);
((OutputLimitContext)_localctx).i = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
{
setState(1841);
((OutputLimitContext)_localctx).e = match(EVENTS);
}
}
break;
}
}
}
break;
case 2:
{
{
setState(1844);
((OutputLimitContext)_localctx).at = match(AT);
setState(1845);
crontabLimitParameterSet();
}
}
break;
case 3:
{
{
setState(1846);
((OutputLimitContext)_localctx).wh = match(WHEN);
setState(1847);
expression();
setState(1850);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1848);
match(THEN);
setState(1849);
onSetExpr();
}
}
}
}
break;
case 4:
{
{
setState(1852);
((OutputLimitContext)_localctx).t = match(WHEN);
setState(1853);
match(TERMINATED);
setState(1856);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
case 1:
{
setState(1854);
match(AND_EXPR);
setState(1855);
expression();
}
break;
}
setState(1860);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1858);
match(THEN);
setState(1859);
onSetExpr();
}
}
}
}
break;
case 5:
{
}
break;
}
setState(1866);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(1865);
outputLimitAndTerm();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputLimitAndTermContext extends ParserRuleContext {
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public OnSetExprContext onSetExpr() {
return getRuleContext(OnSetExprContext.class,0);
}
public OutputLimitAndTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputLimitAndTerm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOutputLimitAndTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOutputLimitAndTerm(this);
}
}
public final OutputLimitAndTermContext outputLimitAndTerm() throws RecognitionException {
OutputLimitAndTermContext _localctx = new OutputLimitAndTermContext(_ctx, getState());
enterRule(_localctx, 254, RULE_outputLimitAndTerm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1868);
match(AND_EXPR);
setState(1869);
match(WHEN);
setState(1870);
match(TERMINATED);
setState(1873);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(1871);
match(AND_EXPR);
setState(1872);
expression();
}
}
setState(1877);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1875);
match(THEN);
setState(1876);
onSetExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputLimitAfterContext extends ParserRuleContext {
public Token a;
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public TimePeriodContext timePeriod() {
return getRuleContext(TimePeriodContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode EVENTS() { return getToken(EsperEPL2GrammarParser.EVENTS, 0); }
public OutputLimitAfterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputLimitAfter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOutputLimitAfter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOutputLimitAfter(this);
}
}
public final OutputLimitAfterContext outputLimitAfter() throws RecognitionException {
OutputLimitAfterContext _localctx = new OutputLimitAfterContext(_ctx, getState());
enterRule(_localctx, 256, RULE_outputLimitAfter);
try {
enterOuterAlt(_localctx, 1);
{
setState(1879);
((OutputLimitAfterContext)_localctx).a = match(AFTER);
setState(1884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
case 1:
{
setState(1880);
timePeriod();
}
break;
case 2:
{
setState(1881);
number();
setState(1882);
match(EVENTS);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RowLimitContext extends ParserRuleContext {
public NumberconstantContext n1;
public Token i1;
public Token c;
public Token o;
public NumberconstantContext n2;
public Token i2;
public List numberconstant() {
return getRuleContexts(NumberconstantContext.class);
}
public NumberconstantContext numberconstant(int i) {
return getRuleContext(NumberconstantContext.class,i);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public TerminalNode OFFSET() { return getToken(EsperEPL2GrammarParser.OFFSET, 0); }
public RowLimitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowLimit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRowLimit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRowLimit(this);
}
}
public final RowLimitContext rowLimit() throws RecognitionException {
RowLimitContext _localctx = new RowLimitContext(_ctx, getState());
enterRule(_localctx, 258, RULE_rowLimit);
paraphrases.push("row limit clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1888);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1886);
((RowLimitContext)_localctx).n1 = numberconstant();
}
break;
case IDENT:
{
setState(1887);
((RowLimitContext)_localctx).i1 = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1898);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFSET || _la==COMMA) {
{
setState(1892);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMA:
{
setState(1890);
((RowLimitContext)_localctx).c = match(COMMA);
}
break;
case OFFSET:
{
setState(1891);
((RowLimitContext)_localctx).o = match(OFFSET);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1896);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1894);
((RowLimitContext)_localctx).n2 = numberconstant();
}
break;
case IDENT:
{
setState(1895);
((RowLimitContext)_localctx).i2 = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CrontabLimitParameterSetListContext extends ParserRuleContext {
public List crontabLimitParameterSet() {
return getRuleContexts(CrontabLimitParameterSetContext.class);
}
public CrontabLimitParameterSetContext crontabLimitParameterSet(int i) {
return getRuleContext(CrontabLimitParameterSetContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CrontabLimitParameterSetListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crontabLimitParameterSetList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCrontabLimitParameterSetList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCrontabLimitParameterSetList(this);
}
}
public final CrontabLimitParameterSetListContext crontabLimitParameterSetList() throws RecognitionException {
CrontabLimitParameterSetListContext _localctx = new CrontabLimitParameterSetListContext(_ctx, getState());
enterRule(_localctx, 260, RULE_crontabLimitParameterSetList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1900);
crontabLimitParameterSet();
setState(1905);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,238,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1901);
match(COMMA);
setState(1902);
crontabLimitParameterSet();
}
}
}
setState(1907);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,238,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CrontabLimitParameterSetContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionWithTimeListContext expressionWithTimeList() {
return getRuleContext(ExpressionWithTimeListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public CrontabLimitParameterSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crontabLimitParameterSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCrontabLimitParameterSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCrontabLimitParameterSet(this);
}
}
public final CrontabLimitParameterSetContext crontabLimitParameterSet() throws RecognitionException {
CrontabLimitParameterSetContext _localctx = new CrontabLimitParameterSetContext(_ctx, getState());
enterRule(_localctx, 262, RULE_crontabLimitParameterSet);
try {
enterOuterAlt(_localctx, 1);
{
setState(1908);
match(LPAREN);
setState(1909);
expressionWithTimeList();
setState(1910);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhenClauseContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public WhenClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whenClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterWhenClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitWhenClause(this);
}
}
public final WhenClauseContext whenClause() throws RecognitionException {
WhenClauseContext _localctx = new WhenClauseContext(_ctx, getState());
enterRule(_localctx, 264, RULE_whenClause);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1912);
match(WHEN);
setState(1913);
expression();
setState(1914);
match(THEN);
setState(1915);
expression();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElseClauseContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(EsperEPL2GrammarParser.ELSE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ElseClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elseClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterElseClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitElseClause(this);
}
}
public final ElseClauseContext elseClause() throws RecognitionException {
ElseClauseContext _localctx = new ElseClauseContext(_ctx, getState());
enterRule(_localctx, 266, RULE_elseClause);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1917);
match(ELSE);
setState(1918);
expression();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogContext extends ParserRuleContext {
public TerminalNode MATCH_RECOGNIZE() { return getToken(EsperEPL2GrammarParser.MATCH_RECOGNIZE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public MatchRecogMeasuresContext matchRecogMeasures() {
return getRuleContext(MatchRecogMeasuresContext.class,0);
}
public MatchRecogPatternContext matchRecogPattern() {
return getRuleContext(MatchRecogPatternContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public MatchRecogPartitionByContext matchRecogPartitionBy() {
return getRuleContext(MatchRecogPartitionByContext.class,0);
}
public MatchRecogMatchesSelectionContext matchRecogMatchesSelection() {
return getRuleContext(MatchRecogMatchesSelectionContext.class,0);
}
public MatchRecogMatchesAfterSkipContext matchRecogMatchesAfterSkip() {
return getRuleContext(MatchRecogMatchesAfterSkipContext.class,0);
}
public MatchRecogMatchesIntervalContext matchRecogMatchesInterval() {
return getRuleContext(MatchRecogMatchesIntervalContext.class,0);
}
public MatchRecogDefineContext matchRecogDefine() {
return getRuleContext(MatchRecogDefineContext.class,0);
}
public MatchRecogContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecog; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecog(this);
}
}
public final MatchRecogContext matchRecog() throws RecognitionException {
MatchRecogContext _localctx = new MatchRecogContext(_ctx, getState());
enterRule(_localctx, 268, RULE_matchRecog);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1920);
match(MATCH_RECOGNIZE);
setState(1921);
match(LPAREN);
setState(1923);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1922);
matchRecogPartitionBy();
}
}
setState(1925);
matchRecogMeasures();
setState(1927);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(1926);
matchRecogMatchesSelection();
}
}
setState(1930);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER) {
{
setState(1929);
matchRecogMatchesAfterSkip();
}
}
setState(1932);
matchRecogPattern();
setState(1934);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1933);
matchRecogMatchesInterval();
}
}
setState(1937);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINE) {
{
setState(1936);
matchRecogDefine();
}
}
setState(1939);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPartitionByContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(EsperEPL2GrammarParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogPartitionByContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPartitionBy; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPartitionBy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPartitionBy(this);
}
}
public final MatchRecogPartitionByContext matchRecogPartitionBy() throws RecognitionException {
MatchRecogPartitionByContext _localctx = new MatchRecogPartitionByContext(_ctx, getState());
enterRule(_localctx, 270, RULE_matchRecogPartitionBy);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1941);
match(PARTITION);
setState(1942);
match(BY);
setState(1943);
expression();
setState(1948);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1944);
match(COMMA);
setState(1945);
expression();
}
}
setState(1950);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMeasuresContext extends ParserRuleContext {
public TerminalNode MEASURES() { return getToken(EsperEPL2GrammarParser.MEASURES, 0); }
public List matchRecogMeasureItem() {
return getRuleContexts(MatchRecogMeasureItemContext.class);
}
public MatchRecogMeasureItemContext matchRecogMeasureItem(int i) {
return getRuleContext(MatchRecogMeasureItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogMeasuresContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMeasures; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMeasures(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMeasures(this);
}
}
public final MatchRecogMeasuresContext matchRecogMeasures() throws RecognitionException {
MatchRecogMeasuresContext _localctx = new MatchRecogMeasuresContext(_ctx, getState());
enterRule(_localctx, 272, RULE_matchRecogMeasures);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1951);
match(MEASURES);
setState(1952);
matchRecogMeasureItem();
setState(1957);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1953);
match(COMMA);
setState(1954);
matchRecogMeasureItem();
}
}
setState(1959);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMeasureItemContext extends ParserRuleContext {
public Token i;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MatchRecogMeasureItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMeasureItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMeasureItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMeasureItem(this);
}
}
public final MatchRecogMeasureItemContext matchRecogMeasureItem() throws RecognitionException {
MatchRecogMeasureItemContext _localctx = new MatchRecogMeasureItemContext(_ctx, getState());
enterRule(_localctx, 274, RULE_matchRecogMeasureItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1960);
expression();
setState(1965);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1961);
match(AS);
setState(1963);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1962);
((MatchRecogMeasureItemContext)_localctx).i = match(IDENT);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMatchesSelectionContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode MATCHES() { return getToken(EsperEPL2GrammarParser.MATCHES, 0); }
public MatchRecogMatchesSelectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMatchesSelection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMatchesSelection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMatchesSelection(this);
}
}
public final MatchRecogMatchesSelectionContext matchRecogMatchesSelection() throws RecognitionException {
MatchRecogMatchesSelectionContext _localctx = new MatchRecogMatchesSelectionContext(_ctx, getState());
enterRule(_localctx, 276, RULE_matchRecogMatchesSelection);
try {
enterOuterAlt(_localctx, 1);
{
setState(1967);
match(ALL);
setState(1968);
match(MATCHES);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternContext extends ParserRuleContext {
public TerminalNode PATTERN() { return getToken(EsperEPL2GrammarParser.PATTERN, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public MatchRecogPatternAlterationContext matchRecogPatternAlteration() {
return getRuleContext(MatchRecogPatternAlterationContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public MatchRecogPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPattern(this);
}
}
public final MatchRecogPatternContext matchRecogPattern() throws RecognitionException {
MatchRecogPatternContext _localctx = new MatchRecogPatternContext(_ctx, getState());
enterRule(_localctx, 278, RULE_matchRecogPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(1970);
match(PATTERN);
setState(1971);
match(LPAREN);
setState(1972);
matchRecogPatternAlteration();
setState(1973);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMatchesAfterSkipContext extends ParserRuleContext {
public KeywordAllowedIdentContext i1;
public KeywordAllowedIdentContext i2;
public KeywordAllowedIdentContext i3;
public KeywordAllowedIdentContext i4;
public KeywordAllowedIdentContext i5;
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public List keywordAllowedIdent() {
return getRuleContexts(KeywordAllowedIdentContext.class);
}
public KeywordAllowedIdentContext keywordAllowedIdent(int i) {
return getRuleContext(KeywordAllowedIdentContext.class,i);
}
public MatchRecogMatchesAfterSkipContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMatchesAfterSkip; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMatchesAfterSkip(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMatchesAfterSkip(this);
}
}
public final MatchRecogMatchesAfterSkipContext matchRecogMatchesAfterSkip() throws RecognitionException {
MatchRecogMatchesAfterSkipContext _localctx = new MatchRecogMatchesAfterSkipContext(_ctx, getState());
enterRule(_localctx, 280, RULE_matchRecogMatchesAfterSkip);
try {
enterOuterAlt(_localctx, 1);
{
setState(1975);
match(AFTER);
setState(1976);
((MatchRecogMatchesAfterSkipContext)_localctx).i1 = keywordAllowedIdent();
setState(1977);
((MatchRecogMatchesAfterSkipContext)_localctx).i2 = keywordAllowedIdent();
setState(1978);
((MatchRecogMatchesAfterSkipContext)_localctx).i3 = keywordAllowedIdent();
setState(1979);
((MatchRecogMatchesAfterSkipContext)_localctx).i4 = keywordAllowedIdent();
setState(1980);
((MatchRecogMatchesAfterSkipContext)_localctx).i5 = keywordAllowedIdent();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMatchesIntervalContext extends ParserRuleContext {
public Token i;
public Token t;
public TimePeriodContext timePeriod() {
return getRuleContext(TimePeriodContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode OR_EXPR() { return getToken(EsperEPL2GrammarParser.OR_EXPR, 0); }
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public MatchRecogMatchesIntervalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMatchesInterval; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMatchesInterval(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMatchesInterval(this);
}
}
public final MatchRecogMatchesIntervalContext matchRecogMatchesInterval() throws RecognitionException {
MatchRecogMatchesIntervalContext _localctx = new MatchRecogMatchesIntervalContext(_ctx, getState());
enterRule(_localctx, 282, RULE_matchRecogMatchesInterval);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1982);
((MatchRecogMatchesIntervalContext)_localctx).i = match(IDENT);
setState(1983);
timePeriod();
setState(1986);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR_EXPR) {
{
setState(1984);
match(OR_EXPR);
setState(1985);
((MatchRecogMatchesIntervalContext)_localctx).t = match(TERMINATED);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternAlterationContext extends ParserRuleContext {
public Token o;
public List matchRecogPatternConcat() {
return getRuleContexts(MatchRecogPatternConcatContext.class);
}
public MatchRecogPatternConcatContext matchRecogPatternConcat(int i) {
return getRuleContext(MatchRecogPatternConcatContext.class,i);
}
public List BOR() { return getTokens(EsperEPL2GrammarParser.BOR); }
public TerminalNode BOR(int i) {
return getToken(EsperEPL2GrammarParser.BOR, i);
}
public MatchRecogPatternAlterationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternAlteration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternAlteration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternAlteration(this);
}
}
public final MatchRecogPatternAlterationContext matchRecogPatternAlteration() throws RecognitionException {
MatchRecogPatternAlterationContext _localctx = new MatchRecogPatternAlterationContext(_ctx, getState());
enterRule(_localctx, 284, RULE_matchRecogPatternAlteration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1988);
matchRecogPatternConcat();
setState(1993);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BOR) {
{
{
setState(1989);
((MatchRecogPatternAlterationContext)_localctx).o = match(BOR);
setState(1990);
matchRecogPatternConcat();
}
}
setState(1995);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternConcatContext extends ParserRuleContext {
public List matchRecogPatternUnary() {
return getRuleContexts(MatchRecogPatternUnaryContext.class);
}
public MatchRecogPatternUnaryContext matchRecogPatternUnary(int i) {
return getRuleContext(MatchRecogPatternUnaryContext.class,i);
}
public MatchRecogPatternConcatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternConcat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternConcat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternConcat(this);
}
}
public final MatchRecogPatternConcatContext matchRecogPatternConcat() throws RecognitionException {
MatchRecogPatternConcatContext _localctx = new MatchRecogPatternConcatContext(_ctx, getState());
enterRule(_localctx, 286, RULE_matchRecogPatternConcat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1997);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1996);
matchRecogPatternUnary();
}
}
setState(1999);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==MATCH_RECOGNIZE_PERMUTE || _la==LPAREN || _la==IDENT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternUnaryContext extends ParserRuleContext {
public MatchRecogPatternPermuteContext matchRecogPatternPermute() {
return getRuleContext(MatchRecogPatternPermuteContext.class,0);
}
public MatchRecogPatternNestedContext matchRecogPatternNested() {
return getRuleContext(MatchRecogPatternNestedContext.class,0);
}
public MatchRecogPatternAtomContext matchRecogPatternAtom() {
return getRuleContext(MatchRecogPatternAtomContext.class,0);
}
public MatchRecogPatternUnaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternUnary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternUnary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternUnary(this);
}
}
public final MatchRecogPatternUnaryContext matchRecogPatternUnary() throws RecognitionException {
MatchRecogPatternUnaryContext _localctx = new MatchRecogPatternUnaryContext(_ctx, getState());
enterRule(_localctx, 288, RULE_matchRecogPatternUnary);
try {
setState(2004);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MATCH_RECOGNIZE_PERMUTE:
enterOuterAlt(_localctx, 1);
{
setState(2001);
matchRecogPatternPermute();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(2002);
matchRecogPatternNested();
}
break;
case IDENT:
enterOuterAlt(_localctx, 3);
{
setState(2003);
matchRecogPatternAtom();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternNestedContext extends ParserRuleContext {
public Token s;
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public MatchRecogPatternAlterationContext matchRecogPatternAlteration() {
return getRuleContext(MatchRecogPatternAlterationContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public MatchRecogPatternRepeatContext matchRecogPatternRepeat() {
return getRuleContext(MatchRecogPatternRepeatContext.class,0);
}
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public TerminalNode PLUS() { return getToken(EsperEPL2GrammarParser.PLUS, 0); }
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public MatchRecogPatternNestedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternNested; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternNested(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternNested(this);
}
}
public final MatchRecogPatternNestedContext matchRecogPatternNested() throws RecognitionException {
MatchRecogPatternNestedContext _localctx = new MatchRecogPatternNestedContext(_ctx, getState());
enterRule(_localctx, 290, RULE_matchRecogPatternNested);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2006);
match(LPAREN);
setState(2007);
matchRecogPatternAlteration();
setState(2008);
match(RPAREN);
setState(2012);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(2009);
((MatchRecogPatternNestedContext)_localctx).s = match(STAR);
}
break;
case PLUS:
{
setState(2010);
((MatchRecogPatternNestedContext)_localctx).s = match(PLUS);
}
break;
case QUESTION:
{
setState(2011);
((MatchRecogPatternNestedContext)_localctx).s = match(QUESTION);
}
break;
case MATCH_RECOGNIZE_PERMUTE:
case LPAREN:
case RPAREN:
case LCURLY:
case COMMA:
case BOR:
case IDENT:
break;
default:
break;
}
setState(2015);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(2014);
matchRecogPatternRepeat();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternPermuteContext extends ParserRuleContext {
public TerminalNode MATCH_RECOGNIZE_PERMUTE() { return getToken(EsperEPL2GrammarParser.MATCH_RECOGNIZE_PERMUTE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List matchRecogPatternAlteration() {
return getRuleContexts(MatchRecogPatternAlterationContext.class);
}
public MatchRecogPatternAlterationContext matchRecogPatternAlteration(int i) {
return getRuleContext(MatchRecogPatternAlterationContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogPatternPermuteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternPermute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternPermute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternPermute(this);
}
}
public final MatchRecogPatternPermuteContext matchRecogPatternPermute() throws RecognitionException {
MatchRecogPatternPermuteContext _localctx = new MatchRecogPatternPermuteContext(_ctx, getState());
enterRule(_localctx, 292, RULE_matchRecogPatternPermute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2017);
match(MATCH_RECOGNIZE_PERMUTE);
setState(2018);
match(LPAREN);
setState(2019);
matchRecogPatternAlteration();
setState(2024);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2020);
match(COMMA);
setState(2021);
matchRecogPatternAlteration();
}
}
setState(2026);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2027);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternAtomContext extends ParserRuleContext {
public Token i;
public Token s;
public Token reluctant;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MatchRecogPatternRepeatContext matchRecogPatternRepeat() {
return getRuleContext(MatchRecogPatternRepeatContext.class,0);
}
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public TerminalNode PLUS() { return getToken(EsperEPL2GrammarParser.PLUS, 0); }
public List QUESTION() { return getTokens(EsperEPL2GrammarParser.QUESTION); }
public TerminalNode QUESTION(int i) {
return getToken(EsperEPL2GrammarParser.QUESTION, i);
}
public MatchRecogPatternAtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternAtom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternAtom(this);
}
}
public final MatchRecogPatternAtomContext matchRecogPatternAtom() throws RecognitionException {
MatchRecogPatternAtomContext _localctx = new MatchRecogPatternAtomContext(_ctx, getState());
enterRule(_localctx, 294, RULE_matchRecogPatternAtom);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2029);
((MatchRecogPatternAtomContext)_localctx).i = match(IDENT);
setState(2038);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (STAR - 144)))) != 0)) {
{
setState(2033);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(2030);
((MatchRecogPatternAtomContext)_localctx).s = match(STAR);
}
break;
case PLUS:
{
setState(2031);
((MatchRecogPatternAtomContext)_localctx).s = match(PLUS);
}
break;
case QUESTION:
{
setState(2032);
((MatchRecogPatternAtomContext)_localctx).s = match(QUESTION);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2036);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUESTION) {
{
setState(2035);
((MatchRecogPatternAtomContext)_localctx).reluctant = match(QUESTION);
}
}
}
}
setState(2041);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(2040);
matchRecogPatternRepeat();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternRepeatContext extends ParserRuleContext {
public ExpressionContext e1;
public Token comma;
public ExpressionContext e2;
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public MatchRecogPatternRepeatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternRepeat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternRepeat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternRepeat(this);
}
}
public final MatchRecogPatternRepeatContext matchRecogPatternRepeat() throws RecognitionException {
MatchRecogPatternRepeatContext _localctx = new MatchRecogPatternRepeatContext(_ctx, getState());
enterRule(_localctx, 296, RULE_matchRecogPatternRepeat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2043);
match(LCURLY);
setState(2045);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,259,_ctx) ) {
case 1:
{
setState(2044);
((MatchRecogPatternRepeatContext)_localctx).e1 = expression();
}
break;
}
setState(2048);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2047);
((MatchRecogPatternRepeatContext)_localctx).comma = match(COMMA);
}
}
setState(2051);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2050);
((MatchRecogPatternRepeatContext)_localctx).e2 = expression();
}
}
setState(2053);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogDefineContext extends ParserRuleContext {
public TerminalNode DEFINE() { return getToken(EsperEPL2GrammarParser.DEFINE, 0); }
public List matchRecogDefineItem() {
return getRuleContexts(MatchRecogDefineItemContext.class);
}
public MatchRecogDefineItemContext matchRecogDefineItem(int i) {
return getRuleContext(MatchRecogDefineItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogDefineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogDefine; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogDefine(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogDefine(this);
}
}
public final MatchRecogDefineContext matchRecogDefine() throws RecognitionException {
MatchRecogDefineContext _localctx = new MatchRecogDefineContext(_ctx, getState());
enterRule(_localctx, 298, RULE_matchRecogDefine);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2055);
match(DEFINE);
setState(2056);
matchRecogDefineItem();
setState(2061);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2057);
match(COMMA);
setState(2058);
matchRecogDefineItem();
}
}
setState(2063);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogDefineItemContext extends ParserRuleContext {
public Token i;
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MatchRecogDefineItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogDefineItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogDefineItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogDefineItem(this);
}
}
public final MatchRecogDefineItemContext matchRecogDefineItem() throws RecognitionException {
MatchRecogDefineItemContext _localctx = new MatchRecogDefineItemContext(_ctx, getState());
enterRule(_localctx, 300, RULE_matchRecogDefineItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2064);
((MatchRecogDefineItemContext)_localctx).i = match(IDENT);
setState(2065);
match(AS);
setState(2066);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public CaseExpressionContext caseExpression() {
return getRuleContext(CaseExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 302, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2068);
caseExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseExpressionContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(EsperEPL2GrammarParser.CASE, 0); }
public TerminalNode END() { return getToken(EsperEPL2GrammarParser.END, 0); }
public List whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public ElseClauseContext elseClause() {
return getRuleContext(ElseClauseContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public EvalOrExpressionContext evalOrExpression() {
return getRuleContext(EvalOrExpressionContext.class,0);
}
public CaseExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCaseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCaseExpression(this);
}
}
public final CaseExpressionContext caseExpression() throws RecognitionException {
CaseExpressionContext _localctx = new CaseExpressionContext(_ctx, getState());
enterRule(_localctx, 304, RULE_caseExpression);
int _la;
try {
setState(2098);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,267,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
paraphrases.push("case expression");
setState(2071);
match(CASE);
setState(2073);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2072);
whenClause();
}
}
setState(2075);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(2078);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(2077);
elseClause();
}
}
setState(2080);
match(END);
paraphrases.pop();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
paraphrases.push("case expression");
setState(2084);
match(CASE);
setState(2085);
expression();
setState(2087);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2086);
whenClause();
}
}
setState(2089);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(2092);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(2091);
elseClause();
}
}
setState(2094);
match(END);
paraphrases.pop();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2097);
evalOrExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalOrExpressionContext extends ParserRuleContext {
public Token op;
public List evalAndExpression() {
return getRuleContexts(EvalAndExpressionContext.class);
}
public EvalAndExpressionContext evalAndExpression(int i) {
return getRuleContext(EvalAndExpressionContext.class,i);
}
public List OR_EXPR() { return getTokens(EsperEPL2GrammarParser.OR_EXPR); }
public TerminalNode OR_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.OR_EXPR, i);
}
public EvalOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalOrExpression(this);
}
}
public final EvalOrExpressionContext evalOrExpression() throws RecognitionException {
EvalOrExpressionContext _localctx = new EvalOrExpressionContext(_ctx, getState());
enterRule(_localctx, 306, RULE_evalOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2100);
evalAndExpression();
setState(2105);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_EXPR) {
{
{
setState(2101);
((EvalOrExpressionContext)_localctx).op = match(OR_EXPR);
setState(2102);
evalAndExpression();
}
}
setState(2107);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalAndExpressionContext extends ParserRuleContext {
public Token op;
public List bitWiseExpression() {
return getRuleContexts(BitWiseExpressionContext.class);
}
public BitWiseExpressionContext bitWiseExpression(int i) {
return getRuleContext(BitWiseExpressionContext.class,i);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public EvalAndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalAndExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalAndExpression(this);
}
}
public final EvalAndExpressionContext evalAndExpression() throws RecognitionException {
EvalAndExpressionContext _localctx = new EvalAndExpressionContext(_ctx, getState());
enterRule(_localctx, 308, RULE_evalAndExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2108);
bitWiseExpression();
setState(2113);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,269,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2109);
((EvalAndExpressionContext)_localctx).op = match(AND_EXPR);
setState(2110);
bitWiseExpression();
}
}
}
setState(2115);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,269,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitWiseExpressionContext extends ParserRuleContext {
public List negatedExpression() {
return getRuleContexts(NegatedExpressionContext.class);
}
public NegatedExpressionContext negatedExpression(int i) {
return getRuleContext(NegatedExpressionContext.class,i);
}
public List BAND() { return getTokens(EsperEPL2GrammarParser.BAND); }
public TerminalNode BAND(int i) {
return getToken(EsperEPL2GrammarParser.BAND, i);
}
public List BOR() { return getTokens(EsperEPL2GrammarParser.BOR); }
public TerminalNode BOR(int i) {
return getToken(EsperEPL2GrammarParser.BOR, i);
}
public List BXOR() { return getTokens(EsperEPL2GrammarParser.BXOR); }
public TerminalNode BXOR(int i) {
return getToken(EsperEPL2GrammarParser.BXOR, i);
}
public BitWiseExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitWiseExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBitWiseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBitWiseExpression(this);
}
}
public final BitWiseExpressionContext bitWiseExpression() throws RecognitionException {
BitWiseExpressionContext _localctx = new BitWiseExpressionContext(_ctx, getState());
enterRule(_localctx, 310, RULE_bitWiseExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2116);
negatedExpression();
setState(2121);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & ((1L << (BXOR - 173)) | (1L << (BOR - 173)) | (1L << (BAND - 173)))) != 0)) {
{
{
setState(2117);
_la = _input.LA(1);
if ( !(((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & ((1L << (BXOR - 173)) | (1L << (BOR - 173)) | (1L << (BAND - 173)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2118);
negatedExpression();
}
}
setState(2123);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NegatedExpressionContext extends ParserRuleContext {
public EvalEqualsExpressionContext evalEqualsExpression() {
return getRuleContext(EvalEqualsExpressionContext.class,0);
}
public TerminalNode NOT_EXPR() { return getToken(EsperEPL2GrammarParser.NOT_EXPR, 0); }
public NegatedExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_negatedExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNegatedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNegatedExpression(this);
}
}
public final NegatedExpressionContext negatedExpression() throws RecognitionException {
NegatedExpressionContext _localctx = new NegatedExpressionContext(_ctx, getState());
enterRule(_localctx, 312, RULE_negatedExpression);
try {
setState(2127);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WINDOW:
case BETWEEN:
case ESCAPE:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case ISTREAM:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PREVIOUSCOUNT:
case PREVIOUSWINDOW:
case PRIOR:
case EXISTS:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case CURRENT_TIMESTAMP:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case NEWKW:
case CONTEXT:
case GROUPING:
case GROUPING_ID:
case QUESTION:
case LPAREN:
case LCURLY:
case PLUS:
case MINUS:
case TICKED_STRING_LITERAL:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IDENT:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 1);
{
setState(2124);
evalEqualsExpression();
}
break;
case NOT_EXPR:
enterOuterAlt(_localctx, 2);
{
setState(2125);
match(NOT_EXPR);
setState(2126);
evalEqualsExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalEqualsExpressionContext extends ParserRuleContext {
public Token eq;
public Token is;
public Token isnot;
public Token sqlne;
public Token ne;
public Token a;
public List evalRelationalExpression() {
return getRuleContexts(EvalRelationalExpressionContext.class);
}
public EvalRelationalExpressionContext evalRelationalExpression(int i) {
return getRuleContext(EvalRelationalExpressionContext.class,i);
}
public List NOT_EXPR() { return getTokens(EsperEPL2GrammarParser.NOT_EXPR); }
public TerminalNode NOT_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.NOT_EXPR, i);
}
public List EQUALS() { return getTokens(EsperEPL2GrammarParser.EQUALS); }
public TerminalNode EQUALS(int i) {
return getToken(EsperEPL2GrammarParser.EQUALS, i);
}
public List IS() { return getTokens(EsperEPL2GrammarParser.IS); }
public TerminalNode IS(int i) {
return getToken(EsperEPL2GrammarParser.IS, i);
}
public List SQL_NE() { return getTokens(EsperEPL2GrammarParser.SQL_NE); }
public TerminalNode SQL_NE(int i) {
return getToken(EsperEPL2GrammarParser.SQL_NE, i);
}
public List NOT_EQUAL() { return getTokens(EsperEPL2GrammarParser.NOT_EQUAL); }
public TerminalNode NOT_EQUAL(int i) {
return getToken(EsperEPL2GrammarParser.NOT_EQUAL, i);
}
public List subSelectGroupExpression() {
return getRuleContexts(SubSelectGroupExpressionContext.class);
}
public SubSelectGroupExpressionContext subSelectGroupExpression(int i) {
return getRuleContext(SubSelectGroupExpressionContext.class,i);
}
public List ANY() { return getTokens(EsperEPL2GrammarParser.ANY); }
public TerminalNode ANY(int i) {
return getToken(EsperEPL2GrammarParser.ANY, i);
}
public List SOME() { return getTokens(EsperEPL2GrammarParser.SOME); }
public TerminalNode SOME(int i) {
return getToken(EsperEPL2GrammarParser.SOME, i);
}
public List ALL() { return getTokens(EsperEPL2GrammarParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(EsperEPL2GrammarParser.ALL, i);
}
public List LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public List RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public EvalEqualsExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalEqualsExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalEqualsExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalEqualsExpression(this);
}
}
public final EvalEqualsExpressionContext evalEqualsExpression() throws RecognitionException {
EvalEqualsExpressionContext _localctx = new EvalEqualsExpressionContext(_ctx, getState());
enterRule(_localctx, 314, RULE_evalEqualsExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2129);
evalRelationalExpression();
setState(2156);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IS || ((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & ((1L << (EQUALS - 142)) | (1L << (SQL_NE - 142)) | (1L << (NOT_EQUAL - 142)))) != 0)) {
{
{
setState(2136);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,272,_ctx) ) {
case 1:
{
setState(2130);
((EvalEqualsExpressionContext)_localctx).eq = match(EQUALS);
}
break;
case 2:
{
setState(2131);
((EvalEqualsExpressionContext)_localctx).is = match(IS);
}
break;
case 3:
{
setState(2132);
((EvalEqualsExpressionContext)_localctx).isnot = match(IS);
setState(2133);
match(NOT_EXPR);
}
break;
case 4:
{
setState(2134);
((EvalEqualsExpressionContext)_localctx).sqlne = match(SQL_NE);
}
break;
case 5:
{
setState(2135);
((EvalEqualsExpressionContext)_localctx).ne = match(NOT_EQUAL);
}
break;
}
setState(2152);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WINDOW:
case BETWEEN:
case ESCAPE:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case ISTREAM:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PREVIOUSCOUNT:
case PREVIOUSWINDOW:
case PRIOR:
case EXISTS:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case CURRENT_TIMESTAMP:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case NEWKW:
case CONTEXT:
case GROUPING:
case GROUPING_ID:
case QUESTION:
case LPAREN:
case LCURLY:
case PLUS:
case MINUS:
case TICKED_STRING_LITERAL:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IDENT:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2138);
evalRelationalExpression();
}
break;
case ALL:
case ANY:
case SOME:
{
setState(2142);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ANY:
{
setState(2139);
((EvalEqualsExpressionContext)_localctx).a = match(ANY);
}
break;
case SOME:
{
setState(2140);
((EvalEqualsExpressionContext)_localctx).a = match(SOME);
}
break;
case ALL:
{
setState(2141);
((EvalEqualsExpressionContext)_localctx).a = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) {
case 1:
{
{
setState(2144);
match(LPAREN);
setState(2146);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2145);
expressionList();
}
}
setState(2148);
match(RPAREN);
}
}
break;
case 2:
{
setState(2149);
subSelectGroupExpression();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2158);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalRelationalExpressionContext extends ParserRuleContext {
public Token r;
public Token g;
public Token n;
public Token in;
public Token l;
public Token col;
public Token inset;
public Token between;
public Token like;
public Token regex;
public List concatenationExpr() {
return getRuleContexts(ConcatenationExprContext.class);
}
public ConcatenationExprContext concatenationExpr(int i) {
return getRuleContext(ConcatenationExprContext.class,i);
}
public InSubSelectQueryContext inSubSelectQuery() {
return getRuleContext(InSubSelectQueryContext.class,0);
}
public BetweenListContext betweenList() {
return getRuleContext(BetweenListContext.class,0);
}
public TerminalNode IN_SET() { return getToken(EsperEPL2GrammarParser.IN_SET, 0); }
public TerminalNode BETWEEN() { return getToken(EsperEPL2GrammarParser.BETWEEN, 0); }
public TerminalNode LIKE() { return getToken(EsperEPL2GrammarParser.LIKE, 0); }
public TerminalNode REGEXP() { return getToken(EsperEPL2GrammarParser.REGEXP, 0); }
public TerminalNode NOT_EXPR() { return getToken(EsperEPL2GrammarParser.NOT_EXPR, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ESCAPE() { return getToken(EsperEPL2GrammarParser.ESCAPE, 0); }
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public List LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List LT() { return getTokens(EsperEPL2GrammarParser.LT); }
public TerminalNode LT(int i) {
return getToken(EsperEPL2GrammarParser.LT, i);
}
public List GT() { return getTokens(EsperEPL2GrammarParser.GT); }
public TerminalNode GT(int i) {
return getToken(EsperEPL2GrammarParser.GT, i);
}
public List LE() { return getTokens(EsperEPL2GrammarParser.LE); }
public TerminalNode LE(int i) {
return getToken(EsperEPL2GrammarParser.LE, i);
}
public List GE() { return getTokens(EsperEPL2GrammarParser.GE); }
public TerminalNode GE(int i) {
return getToken(EsperEPL2GrammarParser.GE, i);
}
public List subSelectGroupExpression() {
return getRuleContexts(SubSelectGroupExpressionContext.class);
}
public SubSelectGroupExpressionContext subSelectGroupExpression(int i) {
return getRuleContext(SubSelectGroupExpressionContext.class,i);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public List ANY() { return getTokens(EsperEPL2GrammarParser.ANY); }
public TerminalNode ANY(int i) {
return getToken(EsperEPL2GrammarParser.ANY, i);
}
public List SOME() { return getTokens(EsperEPL2GrammarParser.SOME); }
public TerminalNode SOME(int i) {
return getToken(EsperEPL2GrammarParser.SOME, i);
}
public List ALL() { return getTokens(EsperEPL2GrammarParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(EsperEPL2GrammarParser.ALL, i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public EvalRelationalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalRelationalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalRelationalExpression(this);
}
}
public final EvalRelationalExpressionContext evalRelationalExpression() throws RecognitionException {
EvalRelationalExpressionContext _localctx = new EvalRelationalExpressionContext(_ctx, getState());
enterRule(_localctx, 316, RULE_evalRelationalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2159);
concatenationExpr();
setState(2225);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,291,_ctx) ) {
case 1:
{
{
setState(2184);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 169)) & ~0x3f) == 0 && ((1L << (_la - 169)) & ((1L << (GE - 169)) | (1L << (GT - 169)) | (1L << (LE - 169)) | (1L << (LT - 169)))) != 0)) {
{
{
setState(2164);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LT:
{
setState(2160);
((EvalRelationalExpressionContext)_localctx).r = match(LT);
}
break;
case GT:
{
setState(2161);
((EvalRelationalExpressionContext)_localctx).r = match(GT);
}
break;
case LE:
{
setState(2162);
((EvalRelationalExpressionContext)_localctx).r = match(LE);
}
break;
case GE:
{
setState(2163);
((EvalRelationalExpressionContext)_localctx).r = match(GE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2180);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WINDOW:
case BETWEEN:
case ESCAPE:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case ISTREAM:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PREVIOUSCOUNT:
case PREVIOUSWINDOW:
case PRIOR:
case EXISTS:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case CURRENT_TIMESTAMP:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case NEWKW:
case CONTEXT:
case GROUPING:
case GROUPING_ID:
case QUESTION:
case LPAREN:
case LCURLY:
case PLUS:
case MINUS:
case TICKED_STRING_LITERAL:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IDENT:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2166);
concatenationExpr();
}
break;
case ALL:
case ANY:
case SOME:
{
setState(2170);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ANY:
{
setState(2167);
((EvalRelationalExpressionContext)_localctx).g = match(ANY);
}
break;
case SOME:
{
setState(2168);
((EvalRelationalExpressionContext)_localctx).g = match(SOME);
}
break;
case ALL:
{
setState(2169);
((EvalRelationalExpressionContext)_localctx).g = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,281,_ctx) ) {
case 1:
{
{
setState(2172);
match(LPAREN);
setState(2174);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2173);
expressionList();
}
}
setState(2176);
match(RPAREN);
}
}
break;
case 2:
{
setState(2177);
subSelectGroupExpression();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2186);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case 2:
{
setState(2188);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_EXPR) {
{
setState(2187);
((EvalRelationalExpressionContext)_localctx).n = match(NOT_EXPR);
}
}
setState(2223);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,290,_ctx) ) {
case 1:
{
{
setState(2190);
((EvalRelationalExpressionContext)_localctx).in = match(IN_SET);
setState(2193);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
{
setState(2191);
((EvalRelationalExpressionContext)_localctx).l = match(LPAREN);
}
break;
case LBRACK:
{
setState(2192);
((EvalRelationalExpressionContext)_localctx).l = match(LBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2195);
expression();
setState(2205);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
{
{
setState(2196);
((EvalRelationalExpressionContext)_localctx).col = match(COLON);
{
setState(2197);
expression();
}
}
}
break;
case RPAREN:
case RBRACK:
case COMMA:
{
{
setState(2202);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2198);
match(COMMA);
setState(2199);
expression();
}
}
setState(2204);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2209);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RPAREN:
{
setState(2207);
((EvalRelationalExpressionContext)_localctx).r = match(RPAREN);
}
break;
case RBRACK:
{
setState(2208);
((EvalRelationalExpressionContext)_localctx).r = match(RBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
case 2:
{
setState(2211);
((EvalRelationalExpressionContext)_localctx).inset = match(IN_SET);
setState(2212);
inSubSelectQuery();
}
break;
case 3:
{
setState(2213);
((EvalRelationalExpressionContext)_localctx).between = match(BETWEEN);
setState(2214);
betweenList();
}
break;
case 4:
{
setState(2215);
((EvalRelationalExpressionContext)_localctx).like = match(LIKE);
setState(2216);
concatenationExpr();
setState(2219);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) {
case 1:
{
setState(2217);
match(ESCAPE);
setState(2218);
stringconstant();
}
break;
}
}
break;
case 5:
{
setState(2221);
((EvalRelationalExpressionContext)_localctx).regex = match(REGEXP);
setState(2222);
concatenationExpr();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InSubSelectQueryContext extends ParserRuleContext {
public SubQueryExprContext subQueryExpr() {
return getRuleContext(SubQueryExprContext.class,0);
}
public InSubSelectQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inSubSelectQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterInSubSelectQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitInSubSelectQuery(this);
}
}
public final InSubSelectQueryContext inSubSelectQuery() throws RecognitionException {
InSubSelectQueryContext _localctx = new InSubSelectQueryContext(_ctx, getState());
enterRule(_localctx, 318, RULE_inSubSelectQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(2227);
subQueryExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConcatenationExprContext extends ParserRuleContext {
public Token c;
public List additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public List LOR() { return getTokens(EsperEPL2GrammarParser.LOR); }
public TerminalNode LOR(int i) {
return getToken(EsperEPL2GrammarParser.LOR, i);
}
public ConcatenationExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_concatenationExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterConcatenationExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitConcatenationExpr(this);
}
}
public final ConcatenationExprContext concatenationExpr() throws RecognitionException {
ConcatenationExprContext _localctx = new ConcatenationExprContext(_ctx, getState());
enterRule(_localctx, 320, RULE_concatenationExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2229);
additiveExpression();
setState(2239);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOR) {
{
setState(2230);
((ConcatenationExprContext)_localctx).c = match(LOR);
setState(2231);
additiveExpression();
setState(2236);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOR) {
{
{
setState(2232);
match(LOR);
setState(2233);
additiveExpression();
}
}
setState(2238);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public List multiplyExpression() {
return getRuleContexts(MultiplyExpressionContext.class);
}
public MultiplyExpressionContext multiplyExpression(int i) {
return getRuleContext(MultiplyExpressionContext.class,i);
}
public List PLUS() { return getTokens(EsperEPL2GrammarParser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(EsperEPL2GrammarParser.PLUS, i);
}
public List MINUS() { return getTokens(EsperEPL2GrammarParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(EsperEPL2GrammarParser.MINUS, i);
}
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitAdditiveExpression(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState());
enterRule(_localctx, 322, RULE_additiveExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2241);
multiplyExpression();
setState(2246);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,294,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2242);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2243);
multiplyExpression();
}
}
}
setState(2248);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,294,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiplyExpressionContext extends ParserRuleContext {
public List unaryExpression() {
return getRuleContexts(UnaryExpressionContext.class);
}
public UnaryExpressionContext unaryExpression(int i) {
return getRuleContext(UnaryExpressionContext.class,i);
}
public List STAR() { return getTokens(EsperEPL2GrammarParser.STAR); }
public TerminalNode STAR(int i) {
return getToken(EsperEPL2GrammarParser.STAR, i);
}
public List DIV() { return getTokens(EsperEPL2GrammarParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(EsperEPL2GrammarParser.DIV, i);
}
public List MOD() { return getTokens(EsperEPL2GrammarParser.MOD); }
public TerminalNode MOD(int i) {
return getToken(EsperEPL2GrammarParser.MOD, i);
}
public MultiplyExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplyExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMultiplyExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMultiplyExpression(this);
}
}
public final MultiplyExpressionContext multiplyExpression() throws RecognitionException {
MultiplyExpressionContext _localctx = new MultiplyExpressionContext(_ctx, getState());
enterRule(_localctx, 324, RULE_multiplyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2249);
unaryExpression();
setState(2254);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 157)) & ~0x3f) == 0 && ((1L << (_la - 157)) & ((1L << (DIV - 157)) | (1L << (STAR - 157)) | (1L << (MOD - 157)))) != 0)) {
{
{
setState(2250);
_la = _input.LA(1);
if ( !(((((_la - 157)) & ~0x3f) == 0 && ((1L << (_la - 157)) & ((1L << (DIV - 157)) | (1L << (STAR - 157)) | (1L << (MOD - 157)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2251);
unaryExpression();
}
}
setState(2256);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExpressionContext extends ParserRuleContext {
public Token inner;
public UnaryMinusContext unaryMinus() {
return getRuleContext(UnaryMinusContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public SubstitutionCanChainContext substitutionCanChain() {
return getRuleContext(SubstitutionCanChainContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public BuiltinFuncContext builtinFunc() {
return getRuleContext(BuiltinFuncContext.class,0);
}
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public ArrayExpressionContext arrayExpression() {
return getRuleContext(ArrayExpressionContext.class,0);
}
public RowSubSelectExpressionContext rowSubSelectExpression() {
return getRuleContext(RowSubSelectExpressionContext.class,0);
}
public ExistsSubSelectExpressionContext existsSubSelectExpression() {
return getRuleContext(ExistsSubSelectExpressionContext.class,0);
}
public TerminalNode NEWKW() { return getToken(EsperEPL2GrammarParser.NEWKW, 0); }
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public List newAssign() {
return getRuleContexts(NewAssignContext.class);
}
public NewAssignContext newAssign(int i) {
return getRuleContext(NewAssignContext.class,i);
}
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ClassIdentifierNoDimensionsContext classIdentifierNoDimensions() {
return getRuleContext(ClassIdentifierNoDimensionsContext.class,0);
}
public List LBRACK() { return getTokens(EsperEPL2GrammarParser.LBRACK); }
public TerminalNode LBRACK(int i) {
return getToken(EsperEPL2GrammarParser.LBRACK, i);
}
public List RBRACK() { return getTokens(EsperEPL2GrammarParser.RBRACK); }
public TerminalNode RBRACK(int i) {
return getToken(EsperEPL2GrammarParser.RBRACK, i);
}
public JsonobjectContext jsonobject() {
return getRuleContext(JsonobjectContext.class,0);
}
public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUnaryExpression(this);
}
}
public final UnaryExpressionContext unaryExpression() throws RecognitionException {
UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
enterRule(_localctx, 326, RULE_unaryExpression);
int _la;
try {
setState(2321);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,302,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2257);
unaryMinus();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2258);
constant();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2259);
substitutionCanChain();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2260);
((UnaryExpressionContext)_localctx).inner = match(LPAREN);
setState(2261);
expression();
setState(2262);
match(RPAREN);
setState(2263);
chainableElements();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2265);
builtinFunc();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2266);
chainable();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2267);
arrayExpression();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2268);
rowSubSelectExpression();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2269);
existsSubSelectExpression();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2270);
match(NEWKW);
setState(2271);
match(LCURLY);
setState(2272);
newAssign();
setState(2277);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2273);
match(COMMA);
setState(2274);
newAssign();
}
}
setState(2279);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2280);
match(RCURLY);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2282);
match(NEWKW);
setState(2283);
classIdentifierNoDimensions();
setState(2284);
match(LPAREN);
setState(2293);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2285);
expression();
setState(2290);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2286);
match(COMMA);
setState(2287);
expression();
}
}
setState(2292);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2295);
match(RPAREN);
setState(2296);
chainableElements();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2298);
match(NEWKW);
setState(2299);
classIdentifierNoDimensions();
setState(2300);
match(LBRACK);
setState(2301);
expression();
setState(2302);
match(RBRACK);
setState(2308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2303);
match(LBRACK);
setState(2305);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2304);
expression();
}
}
setState(2307);
match(RBRACK);
}
}
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2310);
match(NEWKW);
setState(2311);
classIdentifierNoDimensions();
setState(2312);
match(LBRACK);
setState(2313);
match(RBRACK);
setState(2316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2314);
match(LBRACK);
setState(2315);
match(RBRACK);
}
}
setState(2318);
arrayExpression();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(2320);
jsonobject();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryMinusContext extends ParserRuleContext {
public TerminalNode MINUS() { return getToken(EsperEPL2GrammarParser.MINUS, 0); }
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public UnaryMinusContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryMinus; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUnaryMinus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUnaryMinus(this);
}
}
public final UnaryMinusContext unaryMinus() throws RecognitionException {
UnaryMinusContext _localctx = new UnaryMinusContext(_ctx, getState());
enterRule(_localctx, 328, RULE_unaryMinus);
try {
enterOuterAlt(_localctx, 1);
{
setState(2323);
match(MINUS);
setState(2324);
chainable();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubstitutionCanChainContext extends ParserRuleContext {
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public SubstitutionCanChainContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substitutionCanChain; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubstitutionCanChain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubstitutionCanChain(this);
}
}
public final SubstitutionCanChainContext substitutionCanChain() throws RecognitionException {
SubstitutionCanChainContext _localctx = new SubstitutionCanChainContext(_ctx, getState());
enterRule(_localctx, 330, RULE_substitutionCanChain);
try {
enterOuterAlt(_localctx, 1);
{
setState(2326);
substitution();
setState(2327);
chainableElements();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewAssignContext extends ParserRuleContext {
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NewAssignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newAssign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNewAssign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNewAssign(this);
}
}
public final NewAssignContext newAssign() throws RecognitionException {
NewAssignContext _localctx = new NewAssignContext(_ctx, getState());
enterRule(_localctx, 332, RULE_newAssign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2329);
chainable();
setState(2332);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(2330);
match(EQUALS);
setState(2331);
expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RowSubSelectExpressionContext extends ParserRuleContext {
public SubQueryExprContext subQueryExpr() {
return getRuleContext(SubQueryExprContext.class,0);
}
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public RowSubSelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowSubSelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRowSubSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRowSubSelectExpression(this);
}
}
public final RowSubSelectExpressionContext rowSubSelectExpression() throws RecognitionException {
RowSubSelectExpressionContext _localctx = new RowSubSelectExpressionContext(_ctx, getState());
enterRule(_localctx, 334, RULE_rowSubSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2334);
subQueryExpr();
setState(2335);
chainableElements();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubSelectGroupExpressionContext extends ParserRuleContext {
public SubQueryExprContext subQueryExpr() {
return getRuleContext(SubQueryExprContext.class,0);
}
public SubSelectGroupExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subSelectGroupExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubSelectGroupExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubSelectGroupExpression(this);
}
}
public final SubSelectGroupExpressionContext subSelectGroupExpression() throws RecognitionException {
SubSelectGroupExpressionContext _localctx = new SubSelectGroupExpressionContext(_ctx, getState());
enterRule(_localctx, 336, RULE_subSelectGroupExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2337);
subQueryExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExistsSubSelectExpressionContext extends ParserRuleContext {
public TerminalNode EXISTS() { return getToken(EsperEPL2GrammarParser.EXISTS, 0); }
public SubQueryExprContext subQueryExpr() {
return getRuleContext(SubQueryExprContext.class,0);
}
public ExistsSubSelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_existsSubSelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExistsSubSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExistsSubSelectExpression(this);
}
}
public final ExistsSubSelectExpressionContext existsSubSelectExpression() throws RecognitionException {
ExistsSubSelectExpressionContext _localctx = new ExistsSubSelectExpressionContext(_ctx, getState());
enterRule(_localctx, 338, RULE_existsSubSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2339);
match(EXISTS);
setState(2340);
subQueryExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryExprContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public SubSelectFilterExprContext subSelectFilterExpr() {
return getRuleContext(SubSelectFilterExprContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode GROUP() { return getToken(EsperEPL2GrammarParser.GROUP, 0); }
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public GroupByListExprContext groupByListExpr() {
return getRuleContext(GroupByListExprContext.class,0);
}
public TerminalNode HAVING() { return getToken(EsperEPL2GrammarParser.HAVING, 0); }
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public SubQueryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubQueryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubQueryExpr(this);
}
}
public final SubQueryExprContext subQueryExpr() throws RecognitionException {
SubQueryExprContext _localctx = new SubQueryExprContext(_ctx, getState());
enterRule(_localctx, 340, RULE_subQueryExpr);
paraphrases.push("subquery");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2342);
match(LPAREN);
setState(2343);
match(SELECT);
setState(2345);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(2344);
match(DISTINCT);
}
}
setState(2347);
selectionList();
setState(2348);
match(FROM);
setState(2349);
subSelectFilterExpr();
setState(2352);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2350);
match(WHERE);
setState(2351);
whereClause();
}
}
setState(2357);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(2354);
match(GROUP);
setState(2355);
match(BY);
setState(2356);
groupByListExpr();
}
}
setState(2361);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(2359);
match(HAVING);
setState(2360);
havingClause();
}
}
setState(2363);
match(RPAREN);
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubSelectFilterExprContext extends ParserRuleContext {
public Token ru;
public Token ri;
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public ViewExpressionsContext viewExpressions() {
return getRuleContext(ViewExpressionsContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public SubSelectFilterExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subSelectFilterExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubSelectFilterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubSelectFilterExpr(this);
}
}
public final SubSelectFilterExprContext subSelectFilterExpr() throws RecognitionException {
SubSelectFilterExprContext _localctx = new SubSelectFilterExprContext(_ctx, getState());
enterRule(_localctx, 342, RULE_subSelectFilterExpr);
paraphrases.push("subquery filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2365);
eventFilterExpression();
setState(2367);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(2366);
viewExpressions();
}
}
setState(2372);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(2369);
match(AS);
setState(2370);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(2371);
identOrTicked();
}
break;
case WHERE:
case GROUP:
case HAVING:
case RETAINUNION:
case RETAININTERSECTION:
case RPAREN:
break;
default:
break;
}
setState(2376);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(2374);
((SubSelectFilterExprContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(2375);
((SubSelectFilterExprContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case WHERE:
case GROUP:
case HAVING:
case RPAREN:
break;
default:
break;
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayExpressionContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ArrayExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterArrayExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitArrayExpression(this);
}
}
public final ArrayExpressionContext arrayExpression() throws RecognitionException {
ArrayExpressionContext _localctx = new ArrayExpressionContext(_ctx, getState());
enterRule(_localctx, 344, RULE_arrayExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2378);
match(LCURLY);
setState(2387);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2379);
expression();
setState(2384);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2380);
match(COMMA);
setState(2381);
expression();
}
}
setState(2386);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2389);
match(RCURLY);
setState(2390);
chainableElements();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BuiltinFuncContext extends ParserRuleContext {
public BuiltinFuncContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_builtinFunc; }
public BuiltinFuncContext() { }
public void copyFrom(BuiltinFuncContext ctx) {
super.copyFrom(ctx);
}
}
public static class Builtin_castContext extends BuiltinFuncContext {
public TerminalNode CAST() { return getToken(EsperEPL2GrammarParser.CAST, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public ExpressionNamedParameterContext expressionNamedParameter() {
return getRuleContext(ExpressionNamedParameterContext.class,0);
}
public Builtin_castContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_cast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_cast(this);
}
}
public static class Builtin_cntContext extends BuiltinFuncContext {
public Token a;
public Token d;
public TerminalNode COUNT() { return getToken(EsperEPL2GrammarParser.COUNT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_cntContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_cnt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_cnt(this);
}
}
public static class Builtin_sumContext extends BuiltinFuncContext {
public TerminalNode SUM() { return getToken(EsperEPL2GrammarParser.SUM, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_sumContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_sum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_sum(this);
}
}
public static class Builtin_priorContext extends BuiltinFuncContext {
public TerminalNode PRIOR() { return getToken(EsperEPL2GrammarParser.PRIOR, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_priorContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_prior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_prior(this);
}
}
public static class Builtin_existsContext extends BuiltinFuncContext {
public TerminalNode EXISTS() { return getToken(EsperEPL2GrammarParser.EXISTS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ChainableContext chainable() {
return getRuleContext(ChainableContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_existsContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_exists(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_exists(this);
}
}
public static class Builtin_prevtailContext extends BuiltinFuncContext {
public TerminalNode PREVIOUSTAIL() { return getToken(EsperEPL2GrammarParser.PREVIOUSTAIL, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public Builtin_prevtailContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_prevtail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_prevtail(this);
}
}
public static class Builtin_istreamContext extends BuiltinFuncContext {
public TerminalNode ISTREAM() { return getToken(EsperEPL2GrammarParser.ISTREAM, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_istreamContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_istream(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_istream(this);
}
}
public static class Builtin_medianContext extends BuiltinFuncContext {
public TerminalNode MEDIAN() { return getToken(EsperEPL2GrammarParser.MEDIAN, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_medianContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_median(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_median(this);
}
}
public static class Builtin_currtsContext extends BuiltinFuncContext {
public TerminalNode CURRENT_TIMESTAMP() { return getToken(EsperEPL2GrammarParser.CURRENT_TIMESTAMP, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_currtsContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_currts(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_currts(this);
}
}
public static class Builtin_coalesceContext extends BuiltinFuncContext {
public TerminalNode COALESCE() { return getToken(EsperEPL2GrammarParser.COALESCE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_coalesceContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_coalesce(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_coalesce(this);
}
}
public static class Builtin_prevContext extends BuiltinFuncContext {
public TerminalNode PREVIOUS() { return getToken(EsperEPL2GrammarParser.PREVIOUS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public Builtin_prevContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_prev(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_prev(this);
}
}
public static class Builtin_prevcountContext extends BuiltinFuncContext {
public TerminalNode PREVIOUSCOUNT() { return getToken(EsperEPL2GrammarParser.PREVIOUSCOUNT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_prevcountContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_prevcount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_prevcount(this);
}
}
public static class Builtin_groupingidContext extends BuiltinFuncContext {
public TerminalNode GROUPING_ID() { return getToken(EsperEPL2GrammarParser.GROUPING_ID, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_groupingidContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_groupingid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_groupingid(this);
}
}
public static class Builtin_prevwindowContext extends BuiltinFuncContext {
public TerminalNode PREVIOUSWINDOW() { return getToken(EsperEPL2GrammarParser.PREVIOUSWINDOW, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public Builtin_prevwindowContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_prevwindow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_prevwindow(this);
}
}
public static class Builtin_stddevContext extends BuiltinFuncContext {
public TerminalNode STDDEV() { return getToken(EsperEPL2GrammarParser.STDDEV, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_stddevContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_stddev(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_stddev(this);
}
}
public static class Builtin_groupingContext extends BuiltinFuncContext {
public TerminalNode GROUPING() { return getToken(EsperEPL2GrammarParser.GROUPING, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_groupingContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_grouping(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_grouping(this);
}
}
public static class Builtin_typeofContext extends BuiltinFuncContext {
public TerminalNode TYPEOF() { return getToken(EsperEPL2GrammarParser.TYPEOF, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_typeofContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_typeof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_typeof(this);
}
}
public static class Builtin_firstlastwindowContext extends BuiltinFuncContext {
public FirstLastWindowAggregationContext firstLastWindowAggregation() {
return getRuleContext(FirstLastWindowAggregationContext.class,0);
}
public Builtin_firstlastwindowContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_firstlastwindow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_firstlastwindow(this);
}
}
public static class Builtin_instanceofContext extends BuiltinFuncContext {
public TerminalNode INSTANCEOF() { return getToken(EsperEPL2GrammarParser.INSTANCEOF, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List classIdentifier() {
return getRuleContexts(ClassIdentifierContext.class);
}
public ClassIdentifierContext classIdentifier(int i) {
return getRuleContext(ClassIdentifierContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_instanceofContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_instanceof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_instanceof(this);
}
}
public static class Builtin_avgContext extends BuiltinFuncContext {
public TerminalNode AVG() { return getToken(EsperEPL2GrammarParser.AVG, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_avgContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_avg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_avg(this);
}
}
public static class Builtin_avedevContext extends BuiltinFuncContext {
public TerminalNode AVEDEV() { return getToken(EsperEPL2GrammarParser.AVEDEV, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_avedevContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_avedev(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_avedev(this);
}
}
public final BuiltinFuncContext builtinFunc() throws RecognitionException {
BuiltinFuncContext _localctx = new BuiltinFuncContext(_ctx, getState());
enterRule(_localctx, 346, RULE_builtinFunc);
int _la;
try {
setState(2549);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SUM:
_localctx = new Builtin_sumContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2392);
match(SUM);
setState(2393);
match(LPAREN);
setState(2395);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2394);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2397);
expressionListWithNamed();
setState(2398);
match(RPAREN);
}
break;
case AVG:
_localctx = new Builtin_avgContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2400);
match(AVG);
setState(2401);
match(LPAREN);
setState(2403);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2402);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2405);
expressionListWithNamed();
setState(2406);
match(RPAREN);
}
break;
case COUNT:
_localctx = new Builtin_cntContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2408);
match(COUNT);
setState(2409);
match(LPAREN);
setState(2412);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
{
setState(2410);
((Builtin_cntContext)_localctx).a = match(ALL);
}
break;
case DISTINCT:
{
setState(2411);
((Builtin_cntContext)_localctx).d = match(DISTINCT);
}
break;
case WINDOW:
case BETWEEN:
case ESCAPE:
case NOT_EXPR:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case CASE:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case ISTREAM:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PREVIOUSCOUNT:
case PREVIOUSWINDOW:
case PRIOR:
case EXISTS:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case CURRENT_TIMESTAMP:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case NEWKW:
case CONTEXT:
case GROUPING:
case GROUPING_ID:
case QUESTION:
case LPAREN:
case LBRACK:
case LCURLY:
case PLUS:
case MINUS:
case STAR:
case TICKED_STRING_LITERAL:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IDENT:
case IntegerLiteral:
case FloatingPointLiteral:
break;
default:
break;
}
setState(2414);
expressionListWithNamed();
setState(2415);
match(RPAREN);
}
break;
case MEDIAN:
_localctx = new Builtin_medianContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2417);
match(MEDIAN);
setState(2418);
match(LPAREN);
setState(2420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2419);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2422);
expressionListWithNamed();
setState(2423);
match(RPAREN);
}
break;
case STDDEV:
_localctx = new Builtin_stddevContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2425);
match(STDDEV);
setState(2426);
match(LPAREN);
setState(2428);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2427);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2430);
expressionListWithNamed();
setState(2431);
match(RPAREN);
}
break;
case AVEDEV:
_localctx = new Builtin_avedevContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2433);
match(AVEDEV);
setState(2434);
match(LPAREN);
setState(2436);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2435);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2438);
expressionListWithNamed();
setState(2439);
match(RPAREN);
}
break;
case WINDOW:
case FIRST:
case LAST:
_localctx = new Builtin_firstlastwindowContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2441);
firstLastWindowAggregation();
}
break;
case COALESCE:
_localctx = new Builtin_coalesceContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(2442);
match(COALESCE);
setState(2443);
match(LPAREN);
setState(2444);
expression();
setState(2445);
match(COMMA);
setState(2446);
expression();
setState(2451);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2447);
match(COMMA);
setState(2448);
expression();
}
}
setState(2453);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2454);
match(RPAREN);
}
break;
case PREVIOUS:
_localctx = new Builtin_prevContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(2456);
match(PREVIOUS);
setState(2457);
match(LPAREN);
setState(2458);
expression();
setState(2461);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2459);
match(COMMA);
setState(2460);
expression();
}
}
setState(2463);
match(RPAREN);
setState(2464);
chainableElements();
}
break;
case PREVIOUSTAIL:
_localctx = new Builtin_prevtailContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(2466);
match(PREVIOUSTAIL);
setState(2467);
match(LPAREN);
setState(2468);
expression();
setState(2471);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2469);
match(COMMA);
setState(2470);
expression();
}
}
setState(2473);
match(RPAREN);
setState(2474);
chainableElements();
}
break;
case PREVIOUSCOUNT:
_localctx = new Builtin_prevcountContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(2476);
match(PREVIOUSCOUNT);
setState(2477);
match(LPAREN);
setState(2478);
expression();
setState(2479);
match(RPAREN);
}
break;
case PREVIOUSWINDOW:
_localctx = new Builtin_prevwindowContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(2481);
match(PREVIOUSWINDOW);
setState(2482);
match(LPAREN);
setState(2483);
expression();
setState(2484);
match(RPAREN);
setState(2485);
chainableElements();
}
break;
case PRIOR:
_localctx = new Builtin_priorContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(2487);
match(PRIOR);
setState(2488);
match(LPAREN);
setState(2489);
expression();
setState(2490);
match(COMMA);
setState(2491);
chainable();
setState(2492);
match(RPAREN);
}
break;
case GROUPING:
_localctx = new Builtin_groupingContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(2494);
match(GROUPING);
setState(2495);
match(LPAREN);
setState(2496);
expression();
setState(2497);
match(RPAREN);
}
break;
case GROUPING_ID:
_localctx = new Builtin_groupingidContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(2499);
match(GROUPING_ID);
setState(2500);
match(LPAREN);
setState(2501);
expressionList();
setState(2502);
match(RPAREN);
}
break;
case INSTANCEOF:
_localctx = new Builtin_instanceofContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(2504);
match(INSTANCEOF);
setState(2505);
match(LPAREN);
setState(2506);
expression();
setState(2507);
match(COMMA);
setState(2508);
classIdentifier();
setState(2513);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2509);
match(COMMA);
setState(2510);
classIdentifier();
}
}
setState(2515);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2516);
match(RPAREN);
}
break;
case TYPEOF:
_localctx = new Builtin_typeofContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(2518);
match(TYPEOF);
setState(2519);
match(LPAREN);
setState(2520);
expression();
setState(2521);
match(RPAREN);
}
break;
case CAST:
_localctx = new Builtin_castContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(2523);
match(CAST);
setState(2524);
match(LPAREN);
setState(2525);
expression();
setState(2526);
_la = _input.LA(1);
if ( !(_la==AS || _la==COMMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2527);
classIdentifierWithDimensions();
setState(2530);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2528);
match(COMMA);
setState(2529);
expressionNamedParameter();
}
}
setState(2532);
match(RPAREN);
setState(2533);
chainableElements();
}
break;
case EXISTS:
_localctx = new Builtin_existsContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(2535);
match(EXISTS);
setState(2536);
match(LPAREN);
setState(2537);
chainable();
setState(2538);
match(RPAREN);
}
break;
case CURRENT_TIMESTAMP:
_localctx = new Builtin_currtsContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(2540);
match(CURRENT_TIMESTAMP);
setState(2543);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,324,_ctx) ) {
case 1:
{
setState(2541);
match(LPAREN);
setState(2542);
match(RPAREN);
}
break;
}
setState(2545);
chainableElements();
}
break;
case ISTREAM:
_localctx = new Builtin_istreamContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(2546);
match(ISTREAM);
setState(2547);
match(LPAREN);
setState(2548);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FirstLastWindowAggregationContext extends ParserRuleContext {
public Token q;
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public TerminalNode WINDOW() { return getToken(EsperEPL2GrammarParser.WINDOW, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public FirstLastWindowAggregationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_firstLastWindowAggregation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFirstLastWindowAggregation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFirstLastWindowAggregation(this);
}
}
public final FirstLastWindowAggregationContext firstLastWindowAggregation() throws RecognitionException {
FirstLastWindowAggregationContext _localctx = new FirstLastWindowAggregationContext(_ctx, getState());
enterRule(_localctx, 348, RULE_firstLastWindowAggregation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2554);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FIRST:
{
setState(2551);
((FirstLastWindowAggregationContext)_localctx).q = match(FIRST);
}
break;
case LAST:
{
setState(2552);
((FirstLastWindowAggregationContext)_localctx).q = match(LAST);
}
break;
case WINDOW:
{
setState(2553);
((FirstLastWindowAggregationContext)_localctx).q = match(WINDOW);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2556);
match(LPAREN);
setState(2558);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2557);
expressionListWithNamed();
}
}
setState(2560);
match(RPAREN);
setState(2561);
chainableElements();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LibFunctionNoClassContext extends ParserRuleContext {
public Token l;
public FuncIdentChainedContext funcIdentChained() {
return getRuleContext(FuncIdentChainedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public LibFunctionArgsContext libFunctionArgs() {
return getRuleContext(LibFunctionArgsContext.class,0);
}
public LibFunctionNoClassContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libFunctionNoClass; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLibFunctionNoClass(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLibFunctionNoClass(this);
}
}
public final LibFunctionNoClassContext libFunctionNoClass() throws RecognitionException {
LibFunctionNoClassContext _localctx = new LibFunctionNoClassContext(_ctx, getState());
enterRule(_localctx, 350, RULE_libFunctionNoClass);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2563);
funcIdentChained();
setState(2569);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2564);
((LibFunctionNoClassContext)_localctx).l = match(LPAREN);
setState(2566);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << DISTINCT) | (1L << ALL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2565);
libFunctionArgs();
}
}
setState(2568);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncIdentChainedContext extends ParserRuleContext {
public EscapableIdentContext escapableIdent() {
return getRuleContext(EscapableIdentContext.class,0);
}
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode WINDOW() { return getToken(EsperEPL2GrammarParser.WINDOW, 0); }
public TerminalNode MAX() { return getToken(EsperEPL2GrammarParser.MAX, 0); }
public TerminalNode MIN() { return getToken(EsperEPL2GrammarParser.MIN, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public TerminalNode BETWEEN() { return getToken(EsperEPL2GrammarParser.BETWEEN, 0); }
public FuncIdentChainedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcIdentChained; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFuncIdentChained(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFuncIdentChained(this);
}
}
public final FuncIdentChainedContext funcIdentChained() throws RecognitionException {
FuncIdentChainedContext _localctx = new FuncIdentChainedContext(_ctx, getState());
enterRule(_localctx, 352, RULE_funcIdentChained);
try {
setState(2581);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2571);
escapableIdent();
}
break;
case LAST:
enterOuterAlt(_localctx, 2);
{
setState(2572);
match(LAST);
}
break;
case FIRST:
enterOuterAlt(_localctx, 3);
{
setState(2573);
match(FIRST);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 4);
{
setState(2574);
match(WINDOW);
}
break;
case MAX:
enterOuterAlt(_localctx, 5);
{
setState(2575);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 6);
{
setState(2576);
match(MIN);
}
break;
case WHERE:
enterOuterAlt(_localctx, 7);
{
setState(2577);
match(WHERE);
}
break;
case SET:
enterOuterAlt(_localctx, 8);
{
setState(2578);
match(SET);
}
break;
case AFTER:
enterOuterAlt(_localctx, 9);
{
setState(2579);
match(AFTER);
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 10);
{
setState(2580);
match(BETWEEN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LibFunctionArgsContext extends ParserRuleContext {
public List libFunctionArgItem() {
return getRuleContexts(LibFunctionArgItemContext.class);
}
public LibFunctionArgItemContext libFunctionArgItem(int i) {
return getRuleContext(LibFunctionArgItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public LibFunctionArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libFunctionArgs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLibFunctionArgs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLibFunctionArgs(this);
}
}
public final LibFunctionArgsContext libFunctionArgs() throws RecognitionException {
LibFunctionArgsContext _localctx = new LibFunctionArgsContext(_ctx, getState());
enterRule(_localctx, 354, RULE_libFunctionArgs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2584);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2583);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2586);
libFunctionArgItem();
setState(2591);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2587);
match(COMMA);
setState(2588);
libFunctionArgItem();
}
}
setState(2593);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LibFunctionArgItemContext extends ParserRuleContext {
public ExpressionWithNamedContext expressionWithNamed() {
return getRuleContext(ExpressionWithNamedContext.class,0);
}
public ExpressionLambdaDeclContext expressionLambdaDecl() {
return getRuleContext(ExpressionLambdaDeclContext.class,0);
}
public LibFunctionArgItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libFunctionArgItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLibFunctionArgItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLibFunctionArgItem(this);
}
}
public final LibFunctionArgItemContext libFunctionArgItem() throws RecognitionException {
LibFunctionArgItemContext _localctx = new LibFunctionArgItemContext(_ctx, getState());
enterRule(_localctx, 356, RULE_libFunctionArgItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2595);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) {
case 1:
{
setState(2594);
expressionLambdaDecl();
}
break;
}
setState(2597);
expressionWithNamed();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BetweenListContext extends ParserRuleContext {
public List concatenationExpr() {
return getRuleContexts(ConcatenationExprContext.class);
}
public ConcatenationExprContext concatenationExpr(int i) {
return getRuleContext(ConcatenationExprContext.class,i);
}
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public BetweenListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_betweenList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBetweenList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBetweenList(this);
}
}
public final BetweenListContext betweenList() throws RecognitionException {
BetweenListContext _localctx = new BetweenListContext(_ctx, getState());
enterRule(_localctx, 358, RULE_betweenList);
try {
enterOuterAlt(_localctx, 1);
{
setState(2599);
concatenationExpr();
setState(2600);
match(AND_EXPR);
setState(2601);
concatenationExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternExpressionContext extends ParserRuleContext {
public FollowedByExpressionContext followedByExpression() {
return getRuleContext(FollowedByExpressionContext.class,0);
}
public PatternExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPatternExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPatternExpression(this);
}
}
public final PatternExpressionContext patternExpression() throws RecognitionException {
PatternExpressionContext _localctx = new PatternExpressionContext(_ctx, getState());
enterRule(_localctx, 360, RULE_patternExpression);
paraphrases.push("pattern expression");
try {
enterOuterAlt(_localctx, 1);
{
setState(2603);
followedByExpression();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FollowedByExpressionContext extends ParserRuleContext {
public OrExpressionContext orExpression() {
return getRuleContext(OrExpressionContext.class,0);
}
public List followedByRepeat() {
return getRuleContexts(FollowedByRepeatContext.class);
}
public FollowedByRepeatContext followedByRepeat(int i) {
return getRuleContext(FollowedByRepeatContext.class,i);
}
public FollowedByExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_followedByExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFollowedByExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFollowedByExpression(this);
}
}
public final FollowedByExpressionContext followedByExpression() throws RecognitionException {
FollowedByExpressionContext _localctx = new FollowedByExpressionContext(_ctx, getState());
enterRule(_localctx, 362, RULE_followedByExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2605);
orExpression();
setState(2609);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOLLOWMAX_BEGIN || _la==FOLLOWED_BY) {
{
{
setState(2606);
followedByRepeat();
}
}
setState(2611);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FollowedByRepeatContext extends ParserRuleContext {
public Token f;
public Token g;
public OrExpressionContext orExpression() {
return getRuleContext(OrExpressionContext.class,0);
}
public TerminalNode FOLLOWED_BY() { return getToken(EsperEPL2GrammarParser.FOLLOWED_BY, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode GT() { return getToken(EsperEPL2GrammarParser.GT, 0); }
public TerminalNode FOLLOWMAX_BEGIN() { return getToken(EsperEPL2GrammarParser.FOLLOWMAX_BEGIN, 0); }
public FollowedByRepeatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_followedByRepeat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFollowedByRepeat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFollowedByRepeat(this);
}
}
public final FollowedByRepeatContext followedByRepeat() throws RecognitionException {
FollowedByRepeatContext _localctx = new FollowedByRepeatContext(_ctx, getState());
enterRule(_localctx, 364, RULE_followedByRepeat);
try {
enterOuterAlt(_localctx, 1);
{
setState(2618);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOLLOWED_BY:
{
setState(2612);
((FollowedByRepeatContext)_localctx).f = match(FOLLOWED_BY);
}
break;
case FOLLOWMAX_BEGIN:
{
{
setState(2613);
((FollowedByRepeatContext)_localctx).g = match(FOLLOWMAX_BEGIN);
setState(2614);
expression();
setState(2615);
match(RBRACK);
setState(2616);
match(GT);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2620);
orExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrExpressionContext extends ParserRuleContext {
public Token o;
public List andExpression() {
return getRuleContexts(AndExpressionContext.class);
}
public AndExpressionContext andExpression(int i) {
return getRuleContext(AndExpressionContext.class,i);
}
public List OR_EXPR() { return getTokens(EsperEPL2GrammarParser.OR_EXPR); }
public TerminalNode OR_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.OR_EXPR, i);
}
public OrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOrExpression(this);
}
}
public final OrExpressionContext orExpression() throws RecognitionException {
OrExpressionContext _localctx = new OrExpressionContext(_ctx, getState());
enterRule(_localctx, 366, RULE_orExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2622);
andExpression();
setState(2627);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_EXPR) {
{
{
setState(2623);
((OrExpressionContext)_localctx).o = match(OR_EXPR);
setState(2624);
andExpression();
}
}
setState(2629);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndExpressionContext extends ParserRuleContext {
public Token a;
public List matchUntilExpression() {
return getRuleContexts(MatchUntilExpressionContext.class);
}
public MatchUntilExpressionContext matchUntilExpression(int i) {
return getRuleContext(MatchUntilExpressionContext.class,i);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public AndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitAndExpression(this);
}
}
public final AndExpressionContext andExpression() throws RecognitionException {
AndExpressionContext _localctx = new AndExpressionContext(_ctx, getState());
enterRule(_localctx, 368, RULE_andExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2630);
matchUntilExpression();
setState(2635);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR) {
{
{
setState(2631);
((AndExpressionContext)_localctx).a = match(AND_EXPR);
setState(2632);
matchUntilExpression();
}
}
setState(2637);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchUntilExpressionContext extends ParserRuleContext {
public MatchUntilRangeContext r;
public QualifyExpressionContext until;
public List qualifyExpression() {
return getRuleContexts(QualifyExpressionContext.class);
}
public QualifyExpressionContext qualifyExpression(int i) {
return getRuleContext(QualifyExpressionContext.class,i);
}
public TerminalNode UNTIL() { return getToken(EsperEPL2GrammarParser.UNTIL, 0); }
public MatchUntilRangeContext matchUntilRange() {
return getRuleContext(MatchUntilRangeContext.class,0);
}
public MatchUntilExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchUntilExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchUntilExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchUntilExpression(this);
}
}
public final MatchUntilExpressionContext matchUntilExpression() throws RecognitionException {
MatchUntilExpressionContext _localctx = new MatchUntilExpressionContext(_ctx, getState());
enterRule(_localctx, 370, RULE_matchUntilExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2639);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2638);
((MatchUntilExpressionContext)_localctx).r = matchUntilRange();
}
}
setState(2641);
qualifyExpression();
setState(2644);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNTIL) {
{
setState(2642);
match(UNTIL);
setState(2643);
((MatchUntilExpressionContext)_localctx).until = qualifyExpression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifyExpressionContext extends ParserRuleContext {
public Token e;
public Token n;
public Token d;
public GuardPostFixContext guardPostFix() {
return getRuleContext(GuardPostFixContext.class,0);
}
public DistinctExpressionListContext distinctExpressionList() {
return getRuleContext(DistinctExpressionListContext.class,0);
}
public TerminalNode EVERY_EXPR() { return getToken(EsperEPL2GrammarParser.EVERY_EXPR, 0); }
public TerminalNode NOT_EXPR() { return getToken(EsperEPL2GrammarParser.NOT_EXPR, 0); }
public TerminalNode EVERY_DISTINCT_EXPR() { return getToken(EsperEPL2GrammarParser.EVERY_DISTINCT_EXPR, 0); }
public MatchUntilRangeContext matchUntilRange() {
return getRuleContext(MatchUntilRangeContext.class,0);
}
public QualifyExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifyExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterQualifyExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitQualifyExpression(this);
}
}
public final QualifyExpressionContext qualifyExpression() throws RecognitionException {
QualifyExpressionContext _localctx = new QualifyExpressionContext(_ctx, getState());
enterRule(_localctx, 372, RULE_qualifyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2655);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << EVERY_DISTINCT_EXPR))) != 0)) {
{
setState(2650);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVERY_EXPR:
{
setState(2646);
((QualifyExpressionContext)_localctx).e = match(EVERY_EXPR);
}
break;
case NOT_EXPR:
{
setState(2647);
((QualifyExpressionContext)_localctx).n = match(NOT_EXPR);
}
break;
case EVERY_DISTINCT_EXPR:
{
setState(2648);
((QualifyExpressionContext)_localctx).d = match(EVERY_DISTINCT_EXPR);
setState(2649);
distinctExpressionList();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2653);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2652);
matchUntilRange();
}
}
}
}
setState(2657);
guardPostFix();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GuardPostFixContext extends ParserRuleContext {
public Token l;
public Token wh;
public Token wi;
public AtomicExpressionContext atomicExpression() {
return getRuleContext(AtomicExpressionContext.class,0);
}
public PatternExpressionContext patternExpression() {
return getRuleContext(PatternExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public GuardWhereExpressionContext guardWhereExpression() {
return getRuleContext(GuardWhereExpressionContext.class,0);
}
public GuardWhileExpressionContext guardWhileExpression() {
return getRuleContext(GuardWhileExpressionContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public TerminalNode WHILE() { return getToken(EsperEPL2GrammarParser.WHILE, 0); }
public GuardPostFixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_guardPostFix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGuardPostFix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGuardPostFix(this);
}
}
public final GuardPostFixContext guardPostFix() throws RecognitionException {
GuardPostFixContext _localctx = new GuardPostFixContext(_ctx, getState());
enterRule(_localctx, 374, RULE_guardPostFix);
try {
enterOuterAlt(_localctx, 1);
{
setState(2664);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(2659);
atomicExpression();
}
break;
case LPAREN:
{
setState(2660);
((GuardPostFixContext)_localctx).l = match(LPAREN);
setState(2661);
patternExpression();
setState(2662);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2670);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WHERE:
{
{
setState(2666);
((GuardPostFixContext)_localctx).wh = match(WHERE);
setState(2667);
guardWhereExpression();
}
}
break;
case WHILE:
{
{
setState(2668);
((GuardPostFixContext)_localctx).wi = match(WHILE);
setState(2669);
guardWhileExpression();
}
}
break;
case OR_EXPR:
case AND_EXPR:
case UNTIL:
case FOLLOWMAX_BEGIN:
case FOLLOWED_BY:
case RPAREN:
case RBRACK:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DistinctExpressionListContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List distinctExpressionAtom() {
return getRuleContexts(DistinctExpressionAtomContext.class);
}
public DistinctExpressionAtomContext distinctExpressionAtom(int i) {
return getRuleContext(DistinctExpressionAtomContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public DistinctExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_distinctExpressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDistinctExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDistinctExpressionList(this);
}
}
public final DistinctExpressionListContext distinctExpressionList() throws RecognitionException {
DistinctExpressionListContext _localctx = new DistinctExpressionListContext(_ctx, getState());
enterRule(_localctx, 376, RULE_distinctExpressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2672);
match(LPAREN);
setState(2673);
distinctExpressionAtom();
setState(2678);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2674);
match(COMMA);
setState(2675);
distinctExpressionAtom();
}
}
setState(2680);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2681);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DistinctExpressionAtomContext extends ParserRuleContext {
public ExpressionWithTimeContext expressionWithTime() {
return getRuleContext(ExpressionWithTimeContext.class,0);
}
public DistinctExpressionAtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_distinctExpressionAtom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDistinctExpressionAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDistinctExpressionAtom(this);
}
}
public final DistinctExpressionAtomContext distinctExpressionAtom() throws RecognitionException {
DistinctExpressionAtomContext _localctx = new DistinctExpressionAtomContext(_ctx, getState());
enterRule(_localctx, 378, RULE_distinctExpressionAtom);
try {
enterOuterAlt(_localctx, 1);
{
setState(2683);
expressionWithTime();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomicExpressionContext extends ParserRuleContext {
public ObserverExpressionContext observerExpression() {
return getRuleContext(ObserverExpressionContext.class,0);
}
public PatternFilterExpressionContext patternFilterExpression() {
return getRuleContext(PatternFilterExpressionContext.class,0);
}
public AtomicExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomicExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterAtomicExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitAtomicExpression(this);
}
}
public final AtomicExpressionContext atomicExpression() throws RecognitionException {
AtomicExpressionContext _localctx = new AtomicExpressionContext(_ctx, getState());
enterRule(_localctx, 380, RULE_atomicExpression);
try {
setState(2687);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,346,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2685);
observerExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2686);
patternFilterExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObserverExpressionContext extends ParserRuleContext {
public Token ns;
public Token nm;
public Token a;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AT() { return getToken(EsperEPL2GrammarParser.AT, 0); }
public ExpressionListWithNamedWithTimeContext expressionListWithNamedWithTime() {
return getRuleContext(ExpressionListWithNamedWithTimeContext.class,0);
}
public ObserverExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_observerExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterObserverExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitObserverExpression(this);
}
}
public final ObserverExpressionContext observerExpression() throws RecognitionException {
ObserverExpressionContext _localctx = new ObserverExpressionContext(_ctx, getState());
enterRule(_localctx, 382, RULE_observerExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2689);
((ObserverExpressionContext)_localctx).ns = match(IDENT);
setState(2690);
match(COLON);
setState(2693);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(2691);
((ObserverExpressionContext)_localctx).nm = match(IDENT);
}
break;
case AT:
{
setState(2692);
((ObserverExpressionContext)_localctx).a = match(AT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2695);
match(LPAREN);
setState(2697);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2696);
expressionListWithNamedWithTime();
}
}
setState(2699);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GuardWhereExpressionContext extends ParserRuleContext {
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionWithTimeListContext expressionWithTimeList() {
return getRuleContext(ExpressionWithTimeListContext.class,0);
}
public GuardWhereExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_guardWhereExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGuardWhereExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGuardWhereExpression(this);
}
}
public final GuardWhereExpressionContext guardWhereExpression() throws RecognitionException {
GuardWhereExpressionContext _localctx = new GuardWhereExpressionContext(_ctx, getState());
enterRule(_localctx, 384, RULE_guardWhereExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2701);
match(IDENT);
setState(2702);
match(COLON);
setState(2703);
match(IDENT);
setState(2704);
match(LPAREN);
setState(2706);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2705);
expressionWithTimeList();
}
}
setState(2708);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GuardWhileExpressionContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public GuardWhileExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_guardWhileExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGuardWhileExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGuardWhileExpression(this);
}
}
public final GuardWhileExpressionContext guardWhileExpression() throws RecognitionException {
GuardWhileExpressionContext _localctx = new GuardWhileExpressionContext(_ctx, getState());
enterRule(_localctx, 386, RULE_guardWhileExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2710);
match(LPAREN);
setState(2711);
expression();
setState(2712);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchUntilRangeContext extends ParserRuleContext {
public ExpressionContext low;
public Token c1;
public ExpressionContext high;
public Token c2;
public ExpressionContext upper;
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public MatchUntilRangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchUntilRange; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchUntilRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchUntilRange(this);
}
}
public final MatchUntilRangeContext matchUntilRange() throws RecognitionException {
MatchUntilRangeContext _localctx = new MatchUntilRangeContext(_ctx, getState());
enterRule(_localctx, 388, RULE_matchUntilRange);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2714);
match(LBRACK);
setState(2724);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WINDOW:
case BETWEEN:
case ESCAPE:
case NOT_EXPR:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case CASE:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case ISTREAM:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PREVIOUSCOUNT:
case PREVIOUSWINDOW:
case PRIOR:
case EXISTS:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case CURRENT_TIMESTAMP:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case NEWKW:
case CONTEXT:
case GROUPING:
case GROUPING_ID:
case QUESTION:
case LPAREN:
case LCURLY:
case PLUS:
case MINUS:
case TICKED_STRING_LITERAL:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IDENT:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2715);
((MatchUntilRangeContext)_localctx).low = expression();
setState(2720);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(2716);
((MatchUntilRangeContext)_localctx).c1 = match(COLON);
setState(2718);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2717);
((MatchUntilRangeContext)_localctx).high = expression();
}
}
}
}
}
break;
case COLON:
{
setState(2722);
((MatchUntilRangeContext)_localctx).c2 = match(COLON);
setState(2723);
((MatchUntilRangeContext)_localctx).upper = expression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2726);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EventFilterExpressionContext extends ParserRuleContext {
public Token i;
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public PropertyExpressionContext propertyExpression() {
return getRuleContext(PropertyExpressionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public EventFilterExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eventFilterExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEventFilterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEventFilterExpression(this);
}
}
public final EventFilterExpressionContext eventFilterExpression() throws RecognitionException {
EventFilterExpressionContext _localctx = new EventFilterExpressionContext(_ctx, getState());
enterRule(_localctx, 390, RULE_eventFilterExpression);
paraphrases.push("filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2730);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,353,_ctx) ) {
case 1:
{
setState(2728);
((EventFilterExpressionContext)_localctx).i = match(IDENT);
setState(2729);
match(EQUALS);
}
break;
}
setState(2732);
classIdentifier();
setState(2738);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2733);
match(LPAREN);
setState(2735);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2734);
expressionList();
}
}
setState(2737);
match(RPAREN);
}
}
setState(2741);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2740);
propertyExpression();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyExpressionContext extends ParserRuleContext {
public List propertyExpressionAtomic() {
return getRuleContexts(PropertyExpressionAtomicContext.class);
}
public PropertyExpressionAtomicContext propertyExpressionAtomic(int i) {
return getRuleContext(PropertyExpressionAtomicContext.class,i);
}
public PropertyExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyExpression(this);
}
}
public final PropertyExpressionContext propertyExpression() throws RecognitionException {
PropertyExpressionContext _localctx = new PropertyExpressionContext(_ctx, getState());
enterRule(_localctx, 392, RULE_propertyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2743);
propertyExpressionAtomic();
setState(2747);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2744);
propertyExpressionAtomic();
}
}
setState(2749);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyExpressionAtomicContext extends ParserRuleContext {
public Token n;
public ExpressionContext where;
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public PropertyExpressionSelectContext propertyExpressionSelect() {
return getRuleContext(PropertyExpressionSelectContext.class,0);
}
public TypeExpressionAnnotationContext typeExpressionAnnotation() {
return getRuleContext(TypeExpressionAnnotationContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public PropertyExpressionAtomicContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyExpressionAtomic; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyExpressionAtomic(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyExpressionAtomic(this);
}
}
public final PropertyExpressionAtomicContext propertyExpressionAtomic() throws RecognitionException {
PropertyExpressionAtomicContext _localctx = new PropertyExpressionAtomicContext(_ctx, getState());
enterRule(_localctx, 394, RULE_propertyExpressionAtomic);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2750);
match(LBRACK);
setState(2752);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(2751);
propertyExpressionSelect();
}
}
setState(2754);
expression();
setState(2756);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(2755);
typeExpressionAnnotation();
}
}
setState(2760);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2758);
match(AS);
setState(2759);
((PropertyExpressionAtomicContext)_localctx).n = match(IDENT);
}
}
setState(2764);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2762);
match(WHERE);
setState(2763);
((PropertyExpressionAtomicContext)_localctx).where = expression();
}
}
setState(2766);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyExpressionSelectContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public PropertySelectionListContext propertySelectionList() {
return getRuleContext(PropertySelectionListContext.class,0);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public PropertyExpressionSelectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyExpressionSelect; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyExpressionSelect(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyExpressionSelect(this);
}
}
public final PropertyExpressionSelectContext propertyExpressionSelect() throws RecognitionException {
PropertyExpressionSelectContext _localctx = new PropertyExpressionSelectContext(_ctx, getState());
enterRule(_localctx, 396, RULE_propertyExpressionSelect);
try {
enterOuterAlt(_localctx, 1);
{
setState(2768);
match(SELECT);
setState(2769);
propertySelectionList();
setState(2770);
match(FROM);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertySelectionListContext extends ParserRuleContext {
public List propertySelectionListElement() {
return getRuleContexts(PropertySelectionListElementContext.class);
}
public PropertySelectionListElementContext propertySelectionListElement(int i) {
return getRuleContext(PropertySelectionListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public PropertySelectionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertySelectionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertySelectionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertySelectionList(this);
}
}
public final PropertySelectionListContext propertySelectionList() throws RecognitionException {
PropertySelectionListContext _localctx = new PropertySelectionListContext(_ctx, getState());
enterRule(_localctx, 398, RULE_propertySelectionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2772);
propertySelectionListElement();
setState(2777);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2773);
match(COMMA);
setState(2774);
propertySelectionListElement();
}
}
setState(2779);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertySelectionListElementContext extends ParserRuleContext {
public Token s;
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public PropertyStreamSelectorContext propertyStreamSelector() {
return getRuleContext(PropertyStreamSelectorContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public PropertySelectionListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertySelectionListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertySelectionListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertySelectionListElement(this);
}
}
public final PropertySelectionListElementContext propertySelectionListElement() throws RecognitionException {
PropertySelectionListElementContext _localctx = new PropertySelectionListElementContext(_ctx, getState());
enterRule(_localctx, 400, RULE_propertySelectionListElement);
int _la;
try {
setState(2787);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,364,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2780);
((PropertySelectionListElementContext)_localctx).s = match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2781);
propertyStreamSelector();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2782);
expression();
setState(2785);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2783);
match(AS);
setState(2784);
keywordAllowedIdent();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyStreamSelectorContext extends ParserRuleContext {
public Token s;
public Token i;
public TerminalNode DOT() { return getToken(EsperEPL2GrammarParser.DOT, 0); }
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public PropertyStreamSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyStreamSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyStreamSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyStreamSelector(this);
}
}
public final PropertyStreamSelectorContext propertyStreamSelector() throws RecognitionException {
PropertyStreamSelectorContext _localctx = new PropertyStreamSelectorContext(_ctx, getState());
enterRule(_localctx, 402, RULE_propertyStreamSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2789);
((PropertyStreamSelectorContext)_localctx).s = match(IDENT);
setState(2790);
match(DOT);
setState(2791);
match(STAR);
setState(2794);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2792);
match(AS);
setState(2793);
((PropertyStreamSelectorContext)_localctx).i = match(IDENT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeExpressionAnnotationContext extends ParserRuleContext {
public Token n;
public Token v;
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TypeExpressionAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeExpressionAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterTypeExpressionAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitTypeExpressionAnnotation(this);
}
}
public final TypeExpressionAnnotationContext typeExpressionAnnotation() throws RecognitionException {
TypeExpressionAnnotationContext _localctx = new TypeExpressionAnnotationContext(_ctx, getState());
enterRule(_localctx, 404, RULE_typeExpressionAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(2796);
match(ATCHAR);
setState(2797);
((TypeExpressionAnnotationContext)_localctx).n = match(IDENT);
{
setState(2798);
match(LPAREN);
setState(2799);
((TypeExpressionAnnotationContext)_localctx).v = match(IDENT);
setState(2800);
match(RPAREN);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternFilterExpressionContext extends ParserRuleContext {
public Token i;
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public PropertyExpressionContext propertyExpression() {
return getRuleContext(PropertyExpressionContext.class,0);
}
public PatternFilterAnnotationContext patternFilterAnnotation() {
return getRuleContext(PatternFilterAnnotationContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public PatternFilterExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternFilterExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPatternFilterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPatternFilterExpression(this);
}
}
public final PatternFilterExpressionContext patternFilterExpression() throws RecognitionException {
PatternFilterExpressionContext _localctx = new PatternFilterExpressionContext(_ctx, getState());
enterRule(_localctx, 406, RULE_patternFilterExpression);
paraphrases.push("filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2804);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,366,_ctx) ) {
case 1:
{
setState(2802);
((PatternFilterExpressionContext)_localctx).i = match(IDENT);
setState(2803);
match(EQUALS);
}
break;
}
setState(2806);
classIdentifier();
setState(2812);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2807);
match(LPAREN);
setState(2809);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2808);
expressionList();
}
}
setState(2811);
match(RPAREN);
}
}
setState(2815);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2814);
propertyExpression();
}
}
setState(2818);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(2817);
patternFilterAnnotation();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternFilterAnnotationContext extends ParserRuleContext {
public Token i;
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public PatternFilterAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternFilterAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPatternFilterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPatternFilterAnnotation(this);
}
}
public final PatternFilterAnnotationContext patternFilterAnnotation() throws RecognitionException {
PatternFilterAnnotationContext _localctx = new PatternFilterAnnotationContext(_ctx, getState());
enterRule(_localctx, 408, RULE_patternFilterAnnotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2820);
match(ATCHAR);
setState(2821);
((PatternFilterAnnotationContext)_localctx).i = match(IDENT);
setState(2826);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2822);
match(LPAREN);
setState(2823);
number();
setState(2824);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassIdentifierNoDimensionsContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ClassIdentifierNoDimensionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classIdentifierNoDimensions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterClassIdentifierNoDimensions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitClassIdentifierNoDimensions(this);
}
}
public final ClassIdentifierNoDimensionsContext classIdentifierNoDimensions() throws RecognitionException {
ClassIdentifierNoDimensionsContext _localctx = new ClassIdentifierNoDimensionsContext(_ctx, getState());
enterRule(_localctx, 410, RULE_classIdentifierNoDimensions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2828);
classIdentifier();
setState(2830);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2829);
typeParameters();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassIdentifierWithDimensionsContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public List dimensions() {
return getRuleContexts(DimensionsContext.class);
}
public DimensionsContext dimensions(int i) {
return getRuleContext(DimensionsContext.class,i);
}
public ClassIdentifierWithDimensionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classIdentifierWithDimensions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterClassIdentifierWithDimensions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitClassIdentifierWithDimensions(this);
}
}
public final ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() throws RecognitionException {
ClassIdentifierWithDimensionsContext _localctx = new ClassIdentifierWithDimensionsContext(_ctx, getState());
enterRule(_localctx, 412, RULE_classIdentifierWithDimensions);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2832);
classIdentifier();
setState(2834);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,373,_ctx) ) {
case 1:
{
setState(2833);
typeParameters();
}
break;
}
setState(2839);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,374,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2836);
dimensions();
}
}
}
setState(2841);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,374,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParametersContext extends ParserRuleContext {
public TerminalNode LT() { return getToken(EsperEPL2GrammarParser.LT, 0); }
public List classIdentifierWithDimensions() {
return getRuleContexts(ClassIdentifierWithDimensionsContext.class);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions(int i) {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,i);
}
public TerminalNode GT() { return getToken(EsperEPL2GrammarParser.GT, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TypeParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitTypeParameters(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 414, RULE_typeParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2842);
match(LT);
setState(2843);
classIdentifierWithDimensions();
setState(2848);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2844);
match(COMMA);
setState(2845);
classIdentifierWithDimensions();
}
}
setState(2850);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2851);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DimensionsContext extends ParserRuleContext {
public Token p;
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public DimensionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dimensions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDimensions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDimensions(this);
}
}
public final DimensionsContext dimensions() throws RecognitionException {
DimensionsContext _localctx = new DimensionsContext(_ctx, getState());
enterRule(_localctx, 416, RULE_dimensions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2853);
match(LBRACK);
setState(2855);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(2854);
((DimensionsContext)_localctx).p = match(IDENT);
}
}
setState(2857);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassIdentifierContext extends ParserRuleContext {
public EscapableStrContext i1;
public EscapableStrContext i2;
public List escapableStr() {
return getRuleContexts(EscapableStrContext.class);
}
public EscapableStrContext escapableStr(int i) {
return getRuleContext(EscapableStrContext.class,i);
}
public List DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public ClassIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterClassIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitClassIdentifier(this);
}
}
public final ClassIdentifierContext classIdentifier() throws RecognitionException {
ClassIdentifierContext _localctx = new ClassIdentifierContext(_ctx, getState());
enterRule(_localctx, 418, RULE_classIdentifier);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2859);
((ClassIdentifierContext)_localctx).i1 = escapableStr();
setState(2864);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,377,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2860);
match(DOT);
setState(2861);
((ClassIdentifierContext)_localctx).i2 = escapableStr();
}
}
}
setState(2866);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,377,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListWithNamedContext extends ParserRuleContext {
public List expressionWithNamed() {
return getRuleContexts(ExpressionWithNamedContext.class);
}
public ExpressionWithNamedContext expressionWithNamed(int i) {
return getRuleContext(ExpressionWithNamedContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionListWithNamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionListWithNamed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionListWithNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionListWithNamed(this);
}
}
public final ExpressionListWithNamedContext expressionListWithNamed() throws RecognitionException {
ExpressionListWithNamedContext _localctx = new ExpressionListWithNamedContext(_ctx, getState());
enterRule(_localctx, 420, RULE_expressionListWithNamed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2867);
expressionWithNamed();
setState(2872);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2868);
match(COMMA);
setState(2869);
expressionWithNamed();
}
}
setState(2874);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListWithNamedWithTimeContext extends ParserRuleContext {
public List expressionWithNamedWithTime() {
return getRuleContexts(ExpressionWithNamedWithTimeContext.class);
}
public ExpressionWithNamedWithTimeContext expressionWithNamedWithTime(int i) {
return getRuleContext(ExpressionWithNamedWithTimeContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionListWithNamedWithTimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionListWithNamedWithTime; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionListWithNamedWithTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionListWithNamedWithTime(this);
}
}
public final ExpressionListWithNamedWithTimeContext expressionListWithNamedWithTime() throws RecognitionException {
ExpressionListWithNamedWithTimeContext _localctx = new ExpressionListWithNamedWithTimeContext(_ctx, getState());
enterRule(_localctx, 422, RULE_expressionListWithNamedWithTime);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2875);
expressionWithNamedWithTime();
setState(2880);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2876);
match(COMMA);
setState(2877);
expressionWithNamedWithTime();
}
}
setState(2882);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionWithNamedContext extends ParserRuleContext {
public ExpressionNamedParameterContext expressionNamedParameter() {
return getRuleContext(ExpressionNamedParameterContext.class,0);
}
public ExpressionWithTimeContext expressionWithTime() {
return getRuleContext(ExpressionWithTimeContext.class,0);
}
public ExpressionWithNamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithNamed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionWithNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionWithNamed(this);
}
}
public final ExpressionWithNamedContext expressionWithNamed() throws RecognitionException {
ExpressionWithNamedContext _localctx = new ExpressionWithNamedContext(_ctx, getState());
enterRule(_localctx, 424, RULE_expressionWithNamed);
try {
setState(2885);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,380,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2883);
expressionNamedParameter();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2884);
expressionWithTime();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionWithNamedWithTimeContext extends ParserRuleContext {
public ExpressionNamedParameterWithTimeContext expressionNamedParameterWithTime() {
return getRuleContext(ExpressionNamedParameterWithTimeContext.class,0);
}
public ExpressionWithTimeInclLastContext expressionWithTimeInclLast() {
return getRuleContext(ExpressionWithTimeInclLastContext.class,0);
}
public ExpressionWithNamedWithTimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithNamedWithTime; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionWithNamedWithTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionWithNamedWithTime(this);
}
}
public final ExpressionWithNamedWithTimeContext expressionWithNamedWithTime() throws RecognitionException {
ExpressionWithNamedWithTimeContext _localctx = new ExpressionWithNamedWithTimeContext(_ctx, getState());
enterRule(_localctx, 426, RULE_expressionWithNamedWithTime);
try {
setState(2889);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,381,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2887);
expressionNamedParameterWithTime();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2888);
expressionWithTimeInclLast();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionNamedParameterContext extends ParserRuleContext {
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ExpressionNamedParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionNamedParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionNamedParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionNamedParameter(this);
}
}
public final ExpressionNamedParameterContext expressionNamedParameter() throws RecognitionException {
ExpressionNamedParameterContext _localctx = new ExpressionNamedParameterContext(_ctx, getState());
enterRule(_localctx, 428, RULE_expressionNamedParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2891);
match(IDENT);
setState(2892);
match(COLON);
setState(2899);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,383,_ctx) ) {
case 1:
{
setState(2893);
expression();
}
break;
case 2:
{
setState(2894);
match(LPAREN);
setState(2896);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2895);
expressionList();
}
}
setState(2898);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionNamedParameterWithTimeContext extends ParserRuleContext {
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public ExpressionWithTimeContext expressionWithTime() {
return getRuleContext(ExpressionWithTimeContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionWithTimeListContext expressionWithTimeList() {
return getRuleContext(ExpressionWithTimeListContext.class,0);
}
public ExpressionNamedParameterWithTimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionNamedParameterWithTime; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionNamedParameterWithTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionNamedParameterWithTime(this);
}
}
public final ExpressionNamedParameterWithTimeContext expressionNamedParameterWithTime() throws RecognitionException {
ExpressionNamedParameterWithTimeContext _localctx = new ExpressionNamedParameterWithTimeContext(_ctx, getState());
enterRule(_localctx, 430, RULE_expressionNamedParameterWithTime);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2901);
match(IDENT);
setState(2902);
match(COLON);
setState(2909);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,385,_ctx) ) {
case 1:
{
setState(2903);
expressionWithTime();
}
break;
case 2:
{
setState(2904);
match(LPAREN);
setState(2906);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(2905);
expressionWithTimeList();
}
}
setState(2908);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionList(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 432, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2911);
expression();
setState(2916);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2912);
match(COMMA);
setState(2913);
expression();
}
}
setState(2918);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionWithTimeListContext extends ParserRuleContext {
public List expressionWithTimeInclLast() {
return getRuleContexts(ExpressionWithTimeInclLastContext.class);
}
public ExpressionWithTimeInclLastContext expressionWithTimeInclLast(int i) {
return getRuleContext(ExpressionWithTimeInclLastContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionWithTimeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithTimeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionWithTimeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionWithTimeList(this);
}
}
public final ExpressionWithTimeListContext expressionWithTimeList() throws RecognitionException {
ExpressionWithTimeListContext _localctx = new ExpressionWithTimeListContext(_ctx, getState());
enterRule(_localctx, 434, RULE_expressionWithTimeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2919);
expressionWithTimeInclLast();
setState(2924);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2920);
match(COMMA);
setState(2921);
expressionWithTimeInclLast();
}
}
setState(2926);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionWithTimeContext extends ParserRuleContext {
public LastWeekdayOperandContext lastWeekdayOperand() {
return getRuleContext(LastWeekdayOperandContext.class,0);
}
public TimePeriodContext timePeriod() {
return getRuleContext(TimePeriodContext.class,0);
}
public ExpressionQualifyableContext expressionQualifyable() {
return getRuleContext(ExpressionQualifyableContext.class,0);
}
public RangeOperandContext rangeOperand() {
return getRuleContext(RangeOperandContext.class,0);
}
public FrequencyOperandContext frequencyOperand() {
return getRuleContext(FrequencyOperandContext.class,0);
}
public LastOperatorContext lastOperator() {
return getRuleContext(LastOperatorContext.class,0);
}
public WeekDayOperatorContext weekDayOperator() {
return getRuleContext(WeekDayOperatorContext.class,0);
}
public NumericParameterListContext numericParameterList() {
return getRuleContext(NumericParameterListContext.class,0);
}
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public PropertyStreamSelectorContext propertyStreamSelector() {
return getRuleContext(PropertyStreamSelectorContext.class,0);
}
public ExpressionWithTimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithTime; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionWithTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionWithTime(this);
}
}
public final ExpressionWithTimeContext expressionWithTime() throws RecognitionException {
ExpressionWithTimeContext _localctx = new ExpressionWithTimeContext(_ctx, getState());
enterRule(_localctx, 436, RULE_expressionWithTime);
try {
setState(2937);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,388,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2927);
lastWeekdayOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2928);
timePeriod();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2929);
expressionQualifyable();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2930);
rangeOperand();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2931);
frequencyOperand();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2932);
lastOperator();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2933);
weekDayOperator();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2934);
numericParameterList();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2935);
match(STAR);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2936);
propertyStreamSelector();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionWithTimeInclLastContext extends ParserRuleContext {
public LastOperandContext lastOperand() {
return getRuleContext(LastOperandContext.class,0);
}
public ExpressionWithTimeContext expressionWithTime() {
return getRuleContext(ExpressionWithTimeContext.class,0);
}
public ExpressionWithTimeInclLastContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithTimeInclLast; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionWithTimeInclLast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionWithTimeInclLast(this);
}
}
public final ExpressionWithTimeInclLastContext expressionWithTimeInclLast() throws RecognitionException {
ExpressionWithTimeInclLastContext _localctx = new ExpressionWithTimeInclLastContext(_ctx, getState());
enterRule(_localctx, 438, RULE_expressionWithTimeInclLast);
try {
setState(2941);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,389,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2939);
lastOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2940);
expressionWithTime();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionQualifyableContext extends ParserRuleContext {
public Token a;
public Token d;
public Token s;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode ASC() { return getToken(EsperEPL2GrammarParser.ASC, 0); }
public TerminalNode DESC() { return getToken(EsperEPL2GrammarParser.DESC, 0); }
public TerminalNode TIMEPERIOD_SECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SECONDS, 0); }
public TerminalNode TIMEPERIOD_SECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SECOND, 0); }
public TerminalNode TIMEPERIOD_SEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SEC, 0); }
public ExpressionQualifyableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionQualifyable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionQualifyable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionQualifyable(this);
}
}
public final ExpressionQualifyableContext expressionQualifyable() throws RecognitionException {
ExpressionQualifyableContext _localctx = new ExpressionQualifyableContext(_ctx, getState());
enterRule(_localctx, 440, RULE_expressionQualifyable);
try {
enterOuterAlt(_localctx, 1);
{
setState(2943);
expression();
setState(2949);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASC:
{
setState(2944);
((ExpressionQualifyableContext)_localctx).a = match(ASC);
}
break;
case DESC:
{
setState(2945);
((ExpressionQualifyableContext)_localctx).d = match(DESC);
}
break;
case TIMEPERIOD_SECONDS:
{
setState(2946);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SECONDS);
}
break;
case TIMEPERIOD_SECOND:
{
setState(2947);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SECOND);
}
break;
case TIMEPERIOD_SEC:
{
setState(2948);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SEC);
}
break;
case RPAREN:
case COMMA:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastWeekdayOperandContext extends ParserRuleContext {
public TerminalNode LW() { return getToken(EsperEPL2GrammarParser.LW, 0); }
public LastWeekdayOperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastWeekdayOperand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLastWeekdayOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLastWeekdayOperand(this);
}
}
public final LastWeekdayOperandContext lastWeekdayOperand() throws RecognitionException {
LastWeekdayOperandContext _localctx = new LastWeekdayOperandContext(_ctx, getState());
enterRule(_localctx, 442, RULE_lastWeekdayOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2951);
match(LW);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastOperandContext extends ParserRuleContext {
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public LastOperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastOperand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLastOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLastOperand(this);
}
}
public final LastOperandContext lastOperand() throws RecognitionException {
LastOperandContext _localctx = new LastOperandContext(_ctx, getState());
enterRule(_localctx, 444, RULE_lastOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2953);
match(LAST);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrequencyOperandContext extends ParserRuleContext {
public Token i;
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public TerminalNode DIV() { return getToken(EsperEPL2GrammarParser.DIV, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public FrequencyOperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frequencyOperand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFrequencyOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFrequencyOperand(this);
}
}
public final FrequencyOperandContext frequencyOperand() throws RecognitionException {
FrequencyOperandContext _localctx = new FrequencyOperandContext(_ctx, getState());
enterRule(_localctx, 446, RULE_frequencyOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2955);
match(STAR);
setState(2956);
match(DIV);
setState(2960);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2957);
number();
}
break;
case IDENT:
{
setState(2958);
((FrequencyOperandContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2959);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeOperandContext extends ParserRuleContext {
public NumberContext n1;
public Token i1;
public SubstitutionContext s1;
public NumberContext n2;
public Token i2;
public SubstitutionContext s2;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public List number() {
return getRuleContexts(NumberContext.class);
}
public NumberContext number(int i) {
return getRuleContext(NumberContext.class,i);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List substitution() {
return getRuleContexts(SubstitutionContext.class);
}
public SubstitutionContext substitution(int i) {
return getRuleContext(SubstitutionContext.class,i);
}
public RangeOperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeOperand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRangeOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRangeOperand(this);
}
}
public final RangeOperandContext rangeOperand() throws RecognitionException {
RangeOperandContext _localctx = new RangeOperandContext(_ctx, getState());
enterRule(_localctx, 448, RULE_rangeOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2965);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2962);
((RangeOperandContext)_localctx).n1 = number();
}
break;
case IDENT:
{
setState(2963);
((RangeOperandContext)_localctx).i1 = match(IDENT);
}
break;
case QUESTION:
{
setState(2964);
((RangeOperandContext)_localctx).s1 = substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2967);
match(COLON);
setState(2971);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2968);
((RangeOperandContext)_localctx).n2 = number();
}
break;
case IDENT:
{
setState(2969);
((RangeOperandContext)_localctx).i2 = match(IDENT);
}
break;
case QUESTION:
{
setState(2970);
((RangeOperandContext)_localctx).s2 = substitution();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastOperatorContext extends ParserRuleContext {
public Token i;
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public LastOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLastOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLastOperator(this);
}
}
public final LastOperatorContext lastOperator() throws RecognitionException {
LastOperatorContext _localctx = new LastOperatorContext(_ctx, getState());
enterRule(_localctx, 450, RULE_lastOperator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2976);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2973);
number();
}
break;
case IDENT:
{
setState(2974);
((LastOperatorContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2975);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2978);
match(LAST);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WeekDayOperatorContext extends ParserRuleContext {
public Token i;
public TerminalNode WEEKDAY() { return getToken(EsperEPL2GrammarParser.WEEKDAY, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public WeekDayOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_weekDayOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterWeekDayOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitWeekDayOperator(this);
}
}
public final WeekDayOperatorContext weekDayOperator() throws RecognitionException {
WeekDayOperatorContext _localctx = new WeekDayOperatorContext(_ctx, getState());
enterRule(_localctx, 452, RULE_weekDayOperator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2983);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2980);
number();
}
break;
case IDENT:
{
setState(2981);
((WeekDayOperatorContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2982);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2985);
match(WEEKDAY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericParameterListContext extends ParserRuleContext {
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List numericListParameter() {
return getRuleContexts(NumericListParameterContext.class);
}
public NumericListParameterContext numericListParameter(int i) {
return getRuleContext(NumericListParameterContext.class,i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public NumericParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNumericParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNumericParameterList(this);
}
}
public final NumericParameterListContext numericParameterList() throws RecognitionException {
NumericParameterListContext _localctx = new NumericParameterListContext(_ctx, getState());
enterRule(_localctx, 454, RULE_numericParameterList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2987);
match(LBRACK);
setState(2988);
numericListParameter();
setState(2993);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2989);
match(COMMA);
setState(2990);
numericListParameter();
}
}
setState(2995);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2996);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericListParameterContext extends ParserRuleContext {
public RangeOperandContext rangeOperand() {
return getRuleContext(RangeOperandContext.class,0);
}
public FrequencyOperandContext frequencyOperand() {
return getRuleContext(FrequencyOperandContext.class,0);
}
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public NumericListParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericListParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNumericListParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNumericListParameter(this);
}
}
public final NumericListParameterContext numericListParameter() throws RecognitionException {
NumericListParameterContext _localctx = new NumericListParameterContext(_ctx, getState());
enterRule(_localctx, 456, RULE_numericListParameter);
try {
setState(3001);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,397,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2998);
rangeOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2999);
frequencyOperand();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3000);
numberconstant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableContext extends ParserRuleContext {
public ChainableRootWithOptContext chainableRootWithOpt() {
return getRuleContext(ChainableRootWithOptContext.class,0);
}
public ChainableElementsContext chainableElements() {
return getRuleContext(ChainableElementsContext.class,0);
}
public ChainableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainable(this);
}
}
public final ChainableContext chainable() throws RecognitionException {
ChainableContext _localctx = new ChainableContext(_ctx, getState());
enterRule(_localctx, 458, RULE_chainable);
try {
enterOuterAlt(_localctx, 1);
{
setState(3003);
chainableRootWithOpt();
setState(3004);
chainableElements();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableRootWithOptContext extends ParserRuleContext {
public Token q;
public ChainableWithArgsContext chainableWithArgs() {
return getRuleContext(ChainableWithArgsContext.class,0);
}
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public ChainableRootWithOptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableRootWithOpt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableRootWithOpt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableRootWithOpt(this);
}
}
public final ChainableRootWithOptContext chainableRootWithOpt() throws RecognitionException {
ChainableRootWithOptContext _localctx = new ChainableRootWithOptContext(_ctx, getState());
enterRule(_localctx, 460, RULE_chainableRootWithOpt);
try {
enterOuterAlt(_localctx, 1);
{
setState(3006);
chainableWithArgs();
setState(3008);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,398,_ctx) ) {
case 1:
{
setState(3007);
((ChainableRootWithOptContext)_localctx).q = match(QUESTION);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableElementsContext extends ParserRuleContext {
public List chainableAtomicWithOpt() {
return getRuleContexts(ChainableAtomicWithOptContext.class);
}
public ChainableAtomicWithOptContext chainableAtomicWithOpt(int i) {
return getRuleContext(ChainableAtomicWithOptContext.class,i);
}
public ChainableElementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableElements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableElements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableElements(this);
}
}
public final ChainableElementsContext chainableElements() throws RecognitionException {
ChainableElementsContext _localctx = new ChainableElementsContext(_ctx, getState());
enterRule(_localctx, 462, RULE_chainableElements);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3013);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK || _la==DOT) {
{
{
setState(3010);
chainableAtomicWithOpt();
}
}
setState(3015);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableAtomicWithOptContext extends ParserRuleContext {
public Token q;
public ChainableAtomicContext chainableAtomic() {
return getRuleContext(ChainableAtomicContext.class,0);
}
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public ChainableAtomicWithOptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableAtomicWithOpt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableAtomicWithOpt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableAtomicWithOpt(this);
}
}
public final ChainableAtomicWithOptContext chainableAtomicWithOpt() throws RecognitionException {
ChainableAtomicWithOptContext _localctx = new ChainableAtomicWithOptContext(_ctx, getState());
enterRule(_localctx, 464, RULE_chainableAtomicWithOpt);
try {
enterOuterAlt(_localctx, 1);
{
setState(3016);
chainableAtomic();
setState(3018);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,400,_ctx) ) {
case 1:
{
setState(3017);
((ChainableAtomicWithOptContext)_localctx).q = match(QUESTION);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableAtomicContext extends ParserRuleContext {
public ChainableArrayContext chainableArray() {
return getRuleContext(ChainableArrayContext.class,0);
}
public TerminalNode DOT() { return getToken(EsperEPL2GrammarParser.DOT, 0); }
public ChainableWithArgsContext chainableWithArgs() {
return getRuleContext(ChainableWithArgsContext.class,0);
}
public ChainableAtomicContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableAtomic; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableAtomic(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableAtomic(this);
}
}
public final ChainableAtomicContext chainableAtomic() throws RecognitionException {
ChainableAtomicContext _localctx = new ChainableAtomicContext(_ctx, getState());
enterRule(_localctx, 466, RULE_chainableAtomic);
try {
setState(3023);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LBRACK:
enterOuterAlt(_localctx, 1);
{
setState(3020);
chainableArray();
}
break;
case DOT:
enterOuterAlt(_localctx, 2);
{
setState(3021);
match(DOT);
setState(3022);
chainableWithArgs();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableArrayContext extends ParserRuleContext {
public Token lb;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ChainableArrayContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableArray; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableArray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableArray(this);
}
}
public final ChainableArrayContext chainableArray() throws RecognitionException {
ChainableArrayContext _localctx = new ChainableArrayContext(_ctx, getState());
enterRule(_localctx, 468, RULE_chainableArray);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3025);
((ChainableArrayContext)_localctx).lb = match(LBRACK);
setState(3026);
expression();
setState(3031);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(3027);
match(COMMA);
setState(3028);
expression();
}
}
setState(3033);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(3034);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableWithArgsContext extends ParserRuleContext {
public Token lp;
public ChainableIdentContext chainableIdent() {
return getRuleContext(ChainableIdentContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public LibFunctionArgsContext libFunctionArgs() {
return getRuleContext(LibFunctionArgsContext.class,0);
}
public ChainableWithArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableWithArgs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableWithArgs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableWithArgs(this);
}
}
public final ChainableWithArgsContext chainableWithArgs() throws RecognitionException {
ChainableWithArgsContext _localctx = new ChainableWithArgsContext(_ctx, getState());
enterRule(_localctx, 470, RULE_chainableWithArgs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3036);
chainableIdent();
setState(3042);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,404,_ctx) ) {
case 1:
{
setState(3037);
((ChainableWithArgsContext)_localctx).lp = match(LPAREN);
setState(3039);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << WINDOW) | (1L << BETWEEN) | (1L << ESCAPE) | (1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << WHERE) | (1L << SUM) | (1L << AVG) | (1L << MAX) | (1L << MIN) | (1L << COALESCE) | (1L << MEDIAN) | (1L << STDDEV) | (1L << AVEDEV) | (1L << COUNT) | (1L << CASE) | (1L << OUTER) | (1L << JOIN) | (1L << LEFT) | (1L << RIGHT) | (1L << FULL) | (1L << DISTINCT) | (1L << ALL) | (1L << EVENTS) | (1L << FIRST) | (1L << LAST) | (1L << ISTREAM) | (1L << SCHEMA) | (1L << UNIDIRECTIONAL) | (1L << RETAINUNION) | (1L << RETAININTERSECTION) | (1L << PATTERN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SQL - 64)) | (1L << (METADATASQL - 64)) | (1L << (PREVIOUS - 64)) | (1L << (PREVIOUSTAIL - 64)) | (1L << (PREVIOUSCOUNT - 64)) | (1L << (PREVIOUSWINDOW - 64)) | (1L << (PRIOR - 64)) | (1L << (EXISTS - 64)) | (1L << (WEEKDAY - 64)) | (1L << (LW - 64)) | (1L << (INSTANCEOF - 64)) | (1L << (TYPEOF - 64)) | (1L << (CAST - 64)) | (1L << (CURRENT_TIMESTAMP - 64)) | (1L << (SNAPSHOT - 64)) | (1L << (SET - 64)) | (1L << (VARIABLE - 64)) | (1L << (TABLE - 64)) | (1L << (UNTIL - 64)) | (1L << (AT - 64)) | (1L << (INDEX - 64)) | (1L << (BOOLEAN_TRUE - 64)) | (1L << (BOOLEAN_FALSE - 64)) | (1L << (VALUE_NULL - 64)) | (1L << (DEFINE - 64)) | (1L << (PARTITION - 64)) | (1L << (MATCHES - 64)) | (1L << (AFTER - 64)) | (1L << (FOR - 64)) | (1L << (WHILE - 64)) | (1L << (USING - 64)) | (1L << (MERGE - 64)) | (1L << (MATCHED - 64)) | (1L << (NEWKW - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (CONTEXT - 129)) | (1L << (GROUPING - 129)) | (1L << (GROUPING_ID - 129)) | (1L << (QUESTION - 129)) | (1L << (LPAREN - 129)) | (1L << (LBRACK - 129)) | (1L << (LCURLY - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (TICKED_STRING_LITERAL - 193)) | (1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IDENT - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(3038);
libFunctionArgs();
}
}
setState(3041);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainableIdentContext extends ParserRuleContext {
public KeywordAllowedIdentContext ipi;
public KeywordAllowedIdentContext ipi2;
public List keywordAllowedIdent() {
return getRuleContexts(KeywordAllowedIdentContext.class);
}
public KeywordAllowedIdentContext keywordAllowedIdent(int i) {
return getRuleContext(KeywordAllowedIdentContext.class,i);
}
public List ESCAPECHAR() { return getTokens(EsperEPL2GrammarParser.ESCAPECHAR); }
public TerminalNode ESCAPECHAR(int i) {
return getToken(EsperEPL2GrammarParser.ESCAPECHAR, i);
}
public List DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public ChainableIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainableIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainableIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainableIdent(this);
}
}
public final ChainableIdentContext chainableIdent() throws RecognitionException {
ChainableIdentContext _localctx = new ChainableIdentContext(_ctx, getState());
enterRule(_localctx, 472, RULE_chainableIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3044);
((ChainableIdentContext)_localctx).ipi = keywordAllowedIdent();
setState(3052);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ESCAPECHAR) {
{
{
setState(3045);
match(ESCAPECHAR);
setState(3046);
match(DOT);
setState(3048);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,405,_ctx) ) {
case 1:
{
setState(3047);
((ChainableIdentContext)_localctx).ipi2 = keywordAllowedIdent();
}
break;
}
}
}
setState(3054);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentOrTickedContext extends ParserRuleContext {
public Token i1;
public Token i2;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode TICKED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.TICKED_STRING_LITERAL, 0); }
public IdentOrTickedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identOrTicked; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterIdentOrTicked(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitIdentOrTicked(this);
}
}
public final IdentOrTickedContext identOrTicked() throws RecognitionException {
IdentOrTickedContext _localctx = new IdentOrTickedContext(_ctx, getState());
enterRule(_localctx, 474, RULE_identOrTicked);
try {
setState(3057);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3055);
((IdentOrTickedContext)_localctx).i1 = match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3056);
((IdentOrTickedContext)_localctx).i2 = match(TICKED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeywordAllowedIdentContext extends ParserRuleContext {
public Token i1;
public Token i2;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode TICKED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.TICKED_STRING_LITERAL, 0); }
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public TerminalNode AT() { return getToken(EsperEPL2GrammarParser.AT, 0); }
public TerminalNode AVG() { return getToken(EsperEPL2GrammarParser.AVG, 0); }
public TerminalNode AVEDEV() { return getToken(EsperEPL2GrammarParser.AVEDEV, 0); }
public TerminalNode BETWEEN() { return getToken(EsperEPL2GrammarParser.BETWEEN, 0); }
public TerminalNode CAST() { return getToken(EsperEPL2GrammarParser.CAST, 0); }
public TerminalNode COALESCE() { return getToken(EsperEPL2GrammarParser.COALESCE, 0); }
public TerminalNode CONTEXT() { return getToken(EsperEPL2GrammarParser.CONTEXT, 0); }
public TerminalNode COUNT() { return getToken(EsperEPL2GrammarParser.COUNT, 0); }
public TerminalNode DEFINE() { return getToken(EsperEPL2GrammarParser.DEFINE, 0); }
public TerminalNode ESCAPE() { return getToken(EsperEPL2GrammarParser.ESCAPE, 0); }
public TerminalNode EVENTS() { return getToken(EsperEPL2GrammarParser.EVENTS, 0); }
public TerminalNode EVERY_EXPR() { return getToken(EsperEPL2GrammarParser.EVERY_EXPR, 0); }
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode FULL() { return getToken(EsperEPL2GrammarParser.FULL, 0); }
public TerminalNode FOR() { return getToken(EsperEPL2GrammarParser.FOR, 0); }
public TerminalNode INDEX() { return getToken(EsperEPL2GrammarParser.INDEX, 0); }
public TerminalNode INSTANCEOF() { return getToken(EsperEPL2GrammarParser.INSTANCEOF, 0); }
public TerminalNode JOIN() { return getToken(EsperEPL2GrammarParser.JOIN, 0); }
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public TerminalNode LEFT() { return getToken(EsperEPL2GrammarParser.LEFT, 0); }
public TerminalNode LW() { return getToken(EsperEPL2GrammarParser.LW, 0); }
public TerminalNode MAX() { return getToken(EsperEPL2GrammarParser.MAX, 0); }
public TerminalNode MATCHED() { return getToken(EsperEPL2GrammarParser.MATCHED, 0); }
public TerminalNode MATCHES() { return getToken(EsperEPL2GrammarParser.MATCHES, 0); }
public TerminalNode MEDIAN() { return getToken(EsperEPL2GrammarParser.MEDIAN, 0); }
public TerminalNode MERGE() { return getToken(EsperEPL2GrammarParser.MERGE, 0); }
public TerminalNode METADATASQL() { return getToken(EsperEPL2GrammarParser.METADATASQL, 0); }
public TerminalNode MIN() { return getToken(EsperEPL2GrammarParser.MIN, 0); }
public TerminalNode OUTER() { return getToken(EsperEPL2GrammarParser.OUTER, 0); }
public TerminalNode PARTITION() { return getToken(EsperEPL2GrammarParser.PARTITION, 0); }
public TerminalNode PATTERN() { return getToken(EsperEPL2GrammarParser.PATTERN, 0); }
public TerminalNode PREVIOUS() { return getToken(EsperEPL2GrammarParser.PREVIOUS, 0); }
public TerminalNode PREVIOUSTAIL() { return getToken(EsperEPL2GrammarParser.PREVIOUSTAIL, 0); }
public TerminalNode PRIOR() { return getToken(EsperEPL2GrammarParser.PRIOR, 0); }
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public TerminalNode RIGHT() { return getToken(EsperEPL2GrammarParser.RIGHT, 0); }
public TerminalNode SCHEMA() { return getToken(EsperEPL2GrammarParser.SCHEMA, 0); }
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public TerminalNode SNAPSHOT() { return getToken(EsperEPL2GrammarParser.SNAPSHOT, 0); }
public TerminalNode STDDEV() { return getToken(EsperEPL2GrammarParser.STDDEV, 0); }
public TerminalNode SUM() { return getToken(EsperEPL2GrammarParser.SUM, 0); }
public TerminalNode SQL() { return getToken(EsperEPL2GrammarParser.SQL, 0); }
public TerminalNode TABLE() { return getToken(EsperEPL2GrammarParser.TABLE, 0); }
public TerminalNode TYPEOF() { return getToken(EsperEPL2GrammarParser.TYPEOF, 0); }
public TerminalNode UNIDIRECTIONAL() { return getToken(EsperEPL2GrammarParser.UNIDIRECTIONAL, 0); }
public TerminalNode UNTIL() { return getToken(EsperEPL2GrammarParser.UNTIL, 0); }
public TerminalNode USING() { return getToken(EsperEPL2GrammarParser.USING, 0); }
public TerminalNode VARIABLE() { return getToken(EsperEPL2GrammarParser.VARIABLE, 0); }
public TerminalNode WEEKDAY() { return getToken(EsperEPL2GrammarParser.WEEKDAY, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public TerminalNode WHILE() { return getToken(EsperEPL2GrammarParser.WHILE, 0); }
public TerminalNode WINDOW() { return getToken(EsperEPL2GrammarParser.WINDOW, 0); }
public KeywordAllowedIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keywordAllowedIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterKeywordAllowedIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitKeywordAllowedIdent(this);
}
}
public final KeywordAllowedIdentContext keywordAllowedIdent() throws RecognitionException {
KeywordAllowedIdentContext _localctx = new KeywordAllowedIdentContext(_ctx, getState());
enterRule(_localctx, 476, RULE_keywordAllowedIdent);
try {
setState(3115);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3059);
((KeywordAllowedIdentContext)_localctx).i1 = match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3060);
((KeywordAllowedIdentContext)_localctx).i2 = match(TICKED_STRING_LITERAL);
}
break;
case AFTER:
enterOuterAlt(_localctx, 3);
{
setState(3061);
match(AFTER);
}
break;
case AT:
enterOuterAlt(_localctx, 4);
{
setState(3062);
match(AT);
}
break;
case AVG:
enterOuterAlt(_localctx, 5);
{
setState(3063);
match(AVG);
}
break;
case AVEDEV:
enterOuterAlt(_localctx, 6);
{
setState(3064);
match(AVEDEV);
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 7);
{
setState(3065);
match(BETWEEN);
}
break;
case CAST:
enterOuterAlt(_localctx, 8);
{
setState(3066);
match(CAST);
}
break;
case COALESCE:
enterOuterAlt(_localctx, 9);
{
setState(3067);
match(COALESCE);
}
break;
case CONTEXT:
enterOuterAlt(_localctx, 10);
{
setState(3068);
match(CONTEXT);
}
break;
case COUNT:
enterOuterAlt(_localctx, 11);
{
setState(3069);
match(COUNT);
}
break;
case DEFINE:
enterOuterAlt(_localctx, 12);
{
setState(3070);
match(DEFINE);
}
break;
case ESCAPE:
enterOuterAlt(_localctx, 13);
{
setState(3071);
match(ESCAPE);
}
break;
case EVENTS:
enterOuterAlt(_localctx, 14);
{
setState(3072);
match(EVENTS);
}
break;
case EVERY_EXPR:
enterOuterAlt(_localctx, 15);
{
setState(3073);
match(EVERY_EXPR);
}
break;
case FIRST:
enterOuterAlt(_localctx, 16);
{
setState(3074);
match(FIRST);
}
break;
case FULL:
enterOuterAlt(_localctx, 17);
{
setState(3075);
match(FULL);
}
break;
case FOR:
enterOuterAlt(_localctx, 18);
{
setState(3076);
match(FOR);
}
break;
case INDEX:
enterOuterAlt(_localctx, 19);
{
setState(3077);
match(INDEX);
}
break;
case INSTANCEOF:
enterOuterAlt(_localctx, 20);
{
setState(3078);
match(INSTANCEOF);
}
break;
case JOIN:
enterOuterAlt(_localctx, 21);
{
setState(3079);
match(JOIN);
}
break;
case LAST:
enterOuterAlt(_localctx, 22);
{
setState(3080);
match(LAST);
}
break;
case LEFT:
enterOuterAlt(_localctx, 23);
{
setState(3081);
match(LEFT);
}
break;
case LW:
enterOuterAlt(_localctx, 24);
{
setState(3082);
match(LW);
}
break;
case MAX:
enterOuterAlt(_localctx, 25);
{
setState(3083);
match(MAX);
}
break;
case MATCHED:
enterOuterAlt(_localctx, 26);
{
setState(3084);
match(MATCHED);
}
break;
case MATCHES:
enterOuterAlt(_localctx, 27);
{
setState(3085);
match(MATCHES);
}
break;
case MEDIAN:
enterOuterAlt(_localctx, 28);
{
setState(3086);
match(MEDIAN);
}
break;
case MERGE:
enterOuterAlt(_localctx, 29);
{
setState(3087);
match(MERGE);
}
break;
case METADATASQL:
enterOuterAlt(_localctx, 30);
{
setState(3088);
match(METADATASQL);
}
break;
case MIN:
enterOuterAlt(_localctx, 31);
{
setState(3089);
match(MIN);
}
break;
case OUTER:
enterOuterAlt(_localctx, 32);
{
setState(3090);
match(OUTER);
}
break;
case PARTITION:
enterOuterAlt(_localctx, 33);
{
setState(3091);
match(PARTITION);
}
break;
case PATTERN:
enterOuterAlt(_localctx, 34);
{
setState(3092);
match(PATTERN);
}
break;
case PREVIOUS:
enterOuterAlt(_localctx, 35);
{
setState(3093);
match(PREVIOUS);
}
break;
case PREVIOUSTAIL:
enterOuterAlt(_localctx, 36);
{
setState(3094);
match(PREVIOUSTAIL);
}
break;
case PRIOR:
enterOuterAlt(_localctx, 37);
{
setState(3095);
match(PRIOR);
}
break;
case RETAINUNION:
enterOuterAlt(_localctx, 38);
{
setState(3096);
match(RETAINUNION);
}
break;
case RETAININTERSECTION:
enterOuterAlt(_localctx, 39);
{
setState(3097);
match(RETAININTERSECTION);
}
break;
case RIGHT:
enterOuterAlt(_localctx, 40);
{
setState(3098);
match(RIGHT);
}
break;
case SCHEMA:
enterOuterAlt(_localctx, 41);
{
setState(3099);
match(SCHEMA);
}
break;
case SET:
enterOuterAlt(_localctx, 42);
{
setState(3100);
match(SET);
}
break;
case SNAPSHOT:
enterOuterAlt(_localctx, 43);
{
setState(3101);
match(SNAPSHOT);
}
break;
case STDDEV:
enterOuterAlt(_localctx, 44);
{
setState(3102);
match(STDDEV);
}
break;
case SUM:
enterOuterAlt(_localctx, 45);
{
setState(3103);
match(SUM);
}
break;
case SQL:
enterOuterAlt(_localctx, 46);
{
setState(3104);
match(SQL);
}
break;
case TABLE:
enterOuterAlt(_localctx, 47);
{
setState(3105);
match(TABLE);
}
break;
case TYPEOF:
enterOuterAlt(_localctx, 48);
{
setState(3106);
match(TYPEOF);
}
break;
case UNIDIRECTIONAL:
enterOuterAlt(_localctx, 49);
{
setState(3107);
match(UNIDIRECTIONAL);
}
break;
case UNTIL:
enterOuterAlt(_localctx, 50);
{
setState(3108);
match(UNTIL);
}
break;
case USING:
enterOuterAlt(_localctx, 51);
{
setState(3109);
match(USING);
}
break;
case VARIABLE:
enterOuterAlt(_localctx, 52);
{
setState(3110);
match(VARIABLE);
}
break;
case WEEKDAY:
enterOuterAlt(_localctx, 53);
{
setState(3111);
match(WEEKDAY);
}
break;
case WHERE:
enterOuterAlt(_localctx, 54);
{
setState(3112);
match(WHERE);
}
break;
case WHILE:
enterOuterAlt(_localctx, 55);
{
setState(3113);
match(WHILE);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 56);
{
setState(3114);
match(WINDOW);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EscapableStrContext extends ParserRuleContext {
public Token i1;
public Token i2;
public Token i3;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode EVENTS() { return getToken(EsperEPL2GrammarParser.EVENTS, 0); }
public TerminalNode TICKED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.TICKED_STRING_LITERAL, 0); }
public EscapableStrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_escapableStr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEscapableStr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEscapableStr(this);
}
}
public final EscapableStrContext escapableStr() throws RecognitionException {
EscapableStrContext _localctx = new EscapableStrContext(_ctx, getState());
enterRule(_localctx, 478, RULE_escapableStr);
try {
setState(3120);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3117);
((EscapableStrContext)_localctx).i1 = match(IDENT);
}
break;
case EVENTS:
enterOuterAlt(_localctx, 2);
{
setState(3118);
((EscapableStrContext)_localctx).i2 = match(EVENTS);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(3119);
((EscapableStrContext)_localctx).i3 = match(TICKED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EscapableIdentContext extends ParserRuleContext {
public Token t;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode TICKED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.TICKED_STRING_LITERAL, 0); }
public EscapableIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_escapableIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEscapableIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEscapableIdent(this);
}
}
public final EscapableIdentContext escapableIdent() throws RecognitionException {
EscapableIdentContext _localctx = new EscapableIdentContext(_ctx, getState());
enterRule(_localctx, 480, RULE_escapableIdent);
try {
setState(3124);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3122);
match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3123);
((EscapableIdentContext)_localctx).t = match(TICKED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimePeriodContext extends ParserRuleContext {
public YearPartContext yearPart() {
return getRuleContext(YearPartContext.class,0);
}
public MonthPartContext monthPart() {
return getRuleContext(MonthPartContext.class,0);
}
public WeekPartContext weekPart() {
return getRuleContext(WeekPartContext.class,0);
}
public DayPartContext dayPart() {
return getRuleContext(DayPartContext.class,0);
}
public HourPartContext hourPart() {
return getRuleContext(HourPartContext.class,0);
}
public MinutePartContext minutePart() {
return getRuleContext(MinutePartContext.class,0);
}
public SecondPartContext secondPart() {
return getRuleContext(SecondPartContext.class,0);
}
public MillisecondPartContext millisecondPart() {
return getRuleContext(MillisecondPartContext.class,0);
}
public MicrosecondPartContext microsecondPart() {
return getRuleContext(MicrosecondPartContext.class,0);
}
public TimePeriodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timePeriod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterTimePeriod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitTimePeriod(this);
}
}
public final TimePeriodContext timePeriod() throws RecognitionException {
TimePeriodContext _localctx = new TimePeriodContext(_ctx, getState());
enterRule(_localctx, 482, RULE_timePeriod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3243);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,447,_ctx) ) {
case 1:
{
setState(3126);
yearPart();
setState(3128);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,411,_ctx) ) {
case 1:
{
setState(3127);
monthPart();
}
break;
}
setState(3131);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,412,_ctx) ) {
case 1:
{
setState(3130);
weekPart();
}
break;
}
setState(3134);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,413,_ctx) ) {
case 1:
{
setState(3133);
dayPart();
}
break;
}
setState(3137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,414,_ctx) ) {
case 1:
{
setState(3136);
hourPart();
}
break;
}
setState(3140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,415,_ctx) ) {
case 1:
{
setState(3139);
minutePart();
}
break;
}
setState(3143);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,416,_ctx) ) {
case 1:
{
setState(3142);
secondPart();
}
break;
}
setState(3146);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,417,_ctx) ) {
case 1:
{
setState(3145);
millisecondPart();
}
break;
}
setState(3149);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3148);
microsecondPart();
}
}
}
break;
case 2:
{
setState(3151);
monthPart();
setState(3153);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,419,_ctx) ) {
case 1:
{
setState(3152);
weekPart();
}
break;
}
setState(3156);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,420,_ctx) ) {
case 1:
{
setState(3155);
dayPart();
}
break;
}
setState(3159);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) {
case 1:
{
setState(3158);
hourPart();
}
break;
}
setState(3162);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) {
case 1:
{
setState(3161);
minutePart();
}
break;
}
setState(3165);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,423,_ctx) ) {
case 1:
{
setState(3164);
secondPart();
}
break;
}
setState(3168);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,424,_ctx) ) {
case 1:
{
setState(3167);
millisecondPart();
}
break;
}
setState(3171);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3170);
microsecondPart();
}
}
}
break;
case 3:
{
setState(3173);
weekPart();
setState(3175);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,426,_ctx) ) {
case 1:
{
setState(3174);
dayPart();
}
break;
}
setState(3178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,427,_ctx) ) {
case 1:
{
setState(3177);
hourPart();
}
break;
}
setState(3181);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,428,_ctx) ) {
case 1:
{
setState(3180);
minutePart();
}
break;
}
setState(3184);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,429,_ctx) ) {
case 1:
{
setState(3183);
secondPart();
}
break;
}
setState(3187);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,430,_ctx) ) {
case 1:
{
setState(3186);
millisecondPart();
}
break;
}
setState(3190);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3189);
microsecondPart();
}
}
}
break;
case 4:
{
setState(3192);
dayPart();
setState(3194);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,432,_ctx) ) {
case 1:
{
setState(3193);
hourPart();
}
break;
}
setState(3197);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,433,_ctx) ) {
case 1:
{
setState(3196);
minutePart();
}
break;
}
setState(3200);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,434,_ctx) ) {
case 1:
{
setState(3199);
secondPart();
}
break;
}
setState(3203);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,435,_ctx) ) {
case 1:
{
setState(3202);
millisecondPart();
}
break;
}
setState(3206);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3205);
microsecondPart();
}
}
}
break;
case 5:
{
setState(3208);
hourPart();
setState(3210);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,437,_ctx) ) {
case 1:
{
setState(3209);
minutePart();
}
break;
}
setState(3213);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,438,_ctx) ) {
case 1:
{
setState(3212);
secondPart();
}
break;
}
setState(3216);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,439,_ctx) ) {
case 1:
{
setState(3215);
millisecondPart();
}
break;
}
setState(3219);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3218);
microsecondPart();
}
}
}
break;
case 6:
{
setState(3221);
minutePart();
setState(3223);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,441,_ctx) ) {
case 1:
{
setState(3222);
secondPart();
}
break;
}
setState(3226);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,442,_ctx) ) {
case 1:
{
setState(3225);
millisecondPart();
}
break;
}
setState(3229);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3228);
microsecondPart();
}
}
}
break;
case 7:
{
setState(3231);
secondPart();
setState(3233);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,444,_ctx) ) {
case 1:
{
setState(3232);
millisecondPart();
}
break;
}
setState(3236);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3235);
microsecondPart();
}
}
}
break;
case 8:
{
setState(3238);
millisecondPart();
setState(3240);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & ((1L << (QUESTION - 144)) | (1L << (PLUS - 144)) | (1L << (MINUS - 144)) | (1L << (IDENT - 144)) | (1L << (IntegerLiteral - 144)) | (1L << (FloatingPointLiteral - 144)))) != 0)) {
{
setState(3239);
microsecondPart();
}
}
}
break;
case 9:
{
setState(3242);
microsecondPart();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class YearPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_YEARS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_YEARS, 0); }
public TerminalNode TIMEPERIOD_YEAR() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_YEAR, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public YearPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_yearPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterYearPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitYearPart(this);
}
}
public final YearPartContext yearPart() throws RecognitionException {
YearPartContext _localctx = new YearPartContext(_ctx, getState());
enterRule(_localctx, 484, RULE_yearPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3248);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3245);
numberconstant();
}
break;
case IDENT:
{
setState(3246);
((YearPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3247);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3250);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_YEAR || _la==TIMEPERIOD_YEARS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MonthPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MONTHS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MONTHS, 0); }
public TerminalNode TIMEPERIOD_MONTH() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MONTH, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MonthPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_monthPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMonthPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMonthPart(this);
}
}
public final MonthPartContext monthPart() throws RecognitionException {
MonthPartContext _localctx = new MonthPartContext(_ctx, getState());
enterRule(_localctx, 486, RULE_monthPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3255);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3252);
numberconstant();
}
break;
case IDENT:
{
setState(3253);
((MonthPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3254);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3257);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_MONTH || _la==TIMEPERIOD_MONTHS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WeekPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_WEEKS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_WEEKS, 0); }
public TerminalNode TIMEPERIOD_WEEK() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_WEEK, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public WeekPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_weekPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterWeekPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitWeekPart(this);
}
}
public final WeekPartContext weekPart() throws RecognitionException {
WeekPartContext _localctx = new WeekPartContext(_ctx, getState());
enterRule(_localctx, 488, RULE_weekPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3262);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3259);
numberconstant();
}
break;
case IDENT:
{
setState(3260);
((WeekPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3261);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3264);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_WEEK || _la==TIMEPERIOD_WEEKS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DayPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_DAYS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_DAYS, 0); }
public TerminalNode TIMEPERIOD_DAY() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_DAY, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public DayPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dayPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDayPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDayPart(this);
}
}
public final DayPartContext dayPart() throws RecognitionException {
DayPartContext _localctx = new DayPartContext(_ctx, getState());
enterRule(_localctx, 490, RULE_dayPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3269);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3266);
numberconstant();
}
break;
case IDENT:
{
setState(3267);
((DayPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3268);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3271);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_DAY || _la==TIMEPERIOD_DAYS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HourPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_HOURS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_HOURS, 0); }
public TerminalNode TIMEPERIOD_HOUR() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_HOUR, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public HourPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hourPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterHourPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitHourPart(this);
}
}
public final HourPartContext hourPart() throws RecognitionException {
HourPartContext _localctx = new HourPartContext(_ctx, getState());
enterRule(_localctx, 492, RULE_hourPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3276);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3273);
numberconstant();
}
break;
case IDENT:
{
setState(3274);
((HourPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3275);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3278);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_HOUR || _la==TIMEPERIOD_HOURS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MinutePartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MINUTES() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MINUTES, 0); }
public TerminalNode TIMEPERIOD_MINUTE() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MINUTE, 0); }
public TerminalNode MIN() { return getToken(EsperEPL2GrammarParser.MIN, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MinutePartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minutePart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMinutePart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMinutePart(this);
}
}
public final MinutePartContext minutePart() throws RecognitionException {
MinutePartContext _localctx = new MinutePartContext(_ctx, getState());
enterRule(_localctx, 494, RULE_minutePart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3283);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3280);
numberconstant();
}
break;
case IDENT:
{
setState(3281);
((MinutePartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3282);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3285);
_la = _input.LA(1);
if ( !(_la==MIN || _la==TIMEPERIOD_MINUTE || _la==TIMEPERIOD_MINUTES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SecondPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_SECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SECONDS, 0); }
public TerminalNode TIMEPERIOD_SECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SECOND, 0); }
public TerminalNode TIMEPERIOD_SEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SEC, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public SecondPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_secondPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSecondPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSecondPart(this);
}
}
public final SecondPartContext secondPart() throws RecognitionException {
SecondPartContext _localctx = new SecondPartContext(_ctx, getState());
enterRule(_localctx, 496, RULE_secondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3290);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3287);
numberconstant();
}
break;
case IDENT:
{
setState(3288);
((SecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3289);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3292);
_la = _input.LA(1);
if ( !(((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & ((1L << (TIMEPERIOD_SEC - 98)) | (1L << (TIMEPERIOD_SECOND - 98)) | (1L << (TIMEPERIOD_SECONDS - 98)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MillisecondPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MILLISECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MILLISECONDS, 0); }
public TerminalNode TIMEPERIOD_MILLISECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MILLISECOND, 0); }
public TerminalNode TIMEPERIOD_MILLISEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MILLISEC, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MillisecondPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_millisecondPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMillisecondPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMillisecondPart(this);
}
}
public final MillisecondPartContext millisecondPart() throws RecognitionException {
MillisecondPartContext _localctx = new MillisecondPartContext(_ctx, getState());
enterRule(_localctx, 498, RULE_millisecondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3297);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3294);
numberconstant();
}
break;
case IDENT:
{
setState(3295);
((MillisecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3296);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3299);
_la = _input.LA(1);
if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (TIMEPERIOD_MILLISEC - 101)) | (1L << (TIMEPERIOD_MILLISECOND - 101)) | (1L << (TIMEPERIOD_MILLISECONDS - 101)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MicrosecondPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MICROSECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MICROSECONDS, 0); }
public TerminalNode TIMEPERIOD_MICROSECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MICROSECOND, 0); }
public TerminalNode TIMEPERIOD_MICROSEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MICROSEC, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MicrosecondPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_microsecondPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMicrosecondPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMicrosecondPart(this);
}
}
public final MicrosecondPartContext microsecondPart() throws RecognitionException {
MicrosecondPartContext _localctx = new MicrosecondPartContext(_ctx, getState());
enterRule(_localctx, 500, RULE_microsecondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3304);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3301);
numberconstant();
}
break;
case IDENT:
{
setState(3302);
((MicrosecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3303);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3306);
_la = _input.LA(1);
if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (TIMEPERIOD_MICROSEC - 104)) | (1L << (TIMEPERIOD_MICROSECOND - 104)) | (1L << (TIMEPERIOD_MICROSECONDS - 104)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberContext extends ParserRuleContext {
public TerminalNode IntegerLiteral() { return getToken(EsperEPL2GrammarParser.IntegerLiteral, 0); }
public TerminalNode FloatingPointLiteral() { return getToken(EsperEPL2GrammarParser.FloatingPointLiteral, 0); }
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNumber(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 502, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3308);
_la = _input.LA(1);
if ( !(_la==IntegerLiteral || _la==FloatingPointLiteral) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubstitutionContext extends ParserRuleContext {
public Token q;
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public List COLON() { return getTokens(EsperEPL2GrammarParser.COLON); }
public TerminalNode COLON(int i) {
return getToken(EsperEPL2GrammarParser.COLON, i);
}
public SubstitutionSlashIdentContext substitutionSlashIdent() {
return getRuleContext(SubstitutionSlashIdentContext.class,0);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public SubstitutionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substitution; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubstitution(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubstitution(this);
}
}
public final SubstitutionContext substitution() throws RecognitionException {
SubstitutionContext _localctx = new SubstitutionContext(_ctx, getState());
enterRule(_localctx, 504, RULE_substitution);
try {
enterOuterAlt(_localctx, 1);
{
setState(3310);
((SubstitutionContext)_localctx).q = match(QUESTION);
setState(3319);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,459,_ctx) ) {
case 1:
{
setState(3311);
match(COLON);
setState(3313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,457,_ctx) ) {
case 1:
{
setState(3312);
substitutionSlashIdent();
}
break;
}
setState(3317);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,458,_ctx) ) {
case 1:
{
setState(3315);
match(COLON);
setState(3316);
classIdentifierWithDimensions();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubstitutionSlashIdentContext extends ParserRuleContext {
public Token d;
public EscapableStrContext i1;
public EscapableStrContext i2;
public List escapableStr() {
return getRuleContexts(EscapableStrContext.class);
}
public EscapableStrContext escapableStr(int i) {
return getRuleContext(EscapableStrContext.class,i);
}
public List DIV() { return getTokens(EsperEPL2GrammarParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(EsperEPL2GrammarParser.DIV, i);
}
public SubstitutionSlashIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substitutionSlashIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubstitutionSlashIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubstitutionSlashIdent(this);
}
}
public final SubstitutionSlashIdentContext substitutionSlashIdent() throws RecognitionException {
SubstitutionSlashIdentContext _localctx = new SubstitutionSlashIdentContext(_ctx, getState());
enterRule(_localctx, 506, RULE_substitutionSlashIdent);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3322);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DIV) {
{
setState(3321);
((SubstitutionSlashIdentContext)_localctx).d = match(DIV);
}
}
setState(3324);
((SubstitutionSlashIdentContext)_localctx).i1 = escapableStr();
setState(3329);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,461,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3325);
match(DIV);
setState(3326);
((SubstitutionSlashIdentContext)_localctx).i2 = escapableStr();
}
}
}
setState(3331);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,461,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantContext extends ParserRuleContext {
public Token t;
public Token f;
public Token nu;
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public TerminalNode BOOLEAN_TRUE() { return getToken(EsperEPL2GrammarParser.BOOLEAN_TRUE, 0); }
public TerminalNode BOOLEAN_FALSE() { return getToken(EsperEPL2GrammarParser.BOOLEAN_FALSE, 0); }
public TerminalNode VALUE_NULL() { return getToken(EsperEPL2GrammarParser.VALUE_NULL, 0); }
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitConstant(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 508, RULE_constant);
try {
setState(3337);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 1);
{
setState(3332);
numberconstant();
}
break;
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3333);
stringconstant();
}
break;
case BOOLEAN_TRUE:
enterOuterAlt(_localctx, 3);
{
setState(3334);
((ConstantContext)_localctx).t = match(BOOLEAN_TRUE);
}
break;
case BOOLEAN_FALSE:
enterOuterAlt(_localctx, 4);
{
setState(3335);
((ConstantContext)_localctx).f = match(BOOLEAN_FALSE);
}
break;
case VALUE_NULL:
enterOuterAlt(_localctx, 5);
{
setState(3336);
((ConstantContext)_localctx).nu = match(VALUE_NULL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberconstantContext extends ParserRuleContext {
public Token m;
public Token p;
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode MINUS() { return getToken(EsperEPL2GrammarParser.MINUS, 0); }
public TerminalNode PLUS() { return getToken(EsperEPL2GrammarParser.PLUS, 0); }
public NumberconstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numberconstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNumberconstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNumberconstant(this);
}
}
public final NumberconstantContext numberconstant() throws RecognitionException {
NumberconstantContext _localctx = new NumberconstantContext(_ctx, getState());
enterRule(_localctx, 510, RULE_numberconstant);
try {
enterOuterAlt(_localctx, 1);
{
setState(3341);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MINUS:
{
setState(3339);
((NumberconstantContext)_localctx).m = match(MINUS);
}
break;
case PLUS:
{
setState(3340);
((NumberconstantContext)_localctx).p = match(PLUS);
}
break;
case IntegerLiteral:
case FloatingPointLiteral:
break;
default:
break;
}
setState(3343);
number();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringconstantContext extends ParserRuleContext {
public Token sl;
public Token qsl;
public TerminalNode STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.STRING_LITERAL, 0); }
public TerminalNode QUOTED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.QUOTED_STRING_LITERAL, 0); }
public StringconstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringconstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStringconstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStringconstant(this);
}
}
public final StringconstantContext stringconstant() throws RecognitionException {
StringconstantContext _localctx = new StringconstantContext(_ctx, getState());
enterRule(_localctx, 512, RULE_stringconstant);
try {
setState(3347);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(3345);
((StringconstantContext)_localctx).sl = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3346);
((StringconstantContext)_localctx).qsl = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonvalueContext extends ParserRuleContext {
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public JsonobjectContext jsonobject() {
return getRuleContext(JsonobjectContext.class,0);
}
public JsonarrayContext jsonarray() {
return getRuleContext(JsonarrayContext.class,0);
}
public JsonvalueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonvalue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonvalue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonvalue(this);
}
}
public final JsonvalueContext jsonvalue() throws RecognitionException {
JsonvalueContext _localctx = new JsonvalueContext(_ctx, getState());
enterRule(_localctx, 514, RULE_jsonvalue);
try {
setState(3352);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case PLUS:
case MINUS:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 1);
{
setState(3349);
constant();
}
break;
case LCURLY:
enterOuterAlt(_localctx, 2);
{
setState(3350);
jsonobject();
}
break;
case LBRACK:
enterOuterAlt(_localctx, 3);
{
setState(3351);
jsonarray();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonobjectContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public JsonmembersContext jsonmembers() {
return getRuleContext(JsonmembersContext.class,0);
}
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public JsonobjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonobject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonobject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonobject(this);
}
}
public final JsonobjectContext jsonobject() throws RecognitionException {
JsonobjectContext _localctx = new JsonobjectContext(_ctx, getState());
enterRule(_localctx, 516, RULE_jsonobject);
try {
enterOuterAlt(_localctx, 1);
{
setState(3354);
match(LCURLY);
setState(3355);
jsonmembers();
setState(3356);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonarrayContext extends ParserRuleContext {
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public JsonelementsContext jsonelements() {
return getRuleContext(JsonelementsContext.class,0);
}
public JsonarrayContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonarray; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonarray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonarray(this);
}
}
public final JsonarrayContext jsonarray() throws RecognitionException {
JsonarrayContext _localctx = new JsonarrayContext(_ctx, getState());
enterRule(_localctx, 518, RULE_jsonarray);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3358);
match(LBRACK);
setState(3360);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (BOOLEAN_TRUE - 107)) | (1L << (BOOLEAN_FALSE - 107)) | (1L << (VALUE_NULL - 107)) | (1L << (LBRACK - 107)) | (1L << (LCURLY - 107)) | (1L << (PLUS - 107)) | (1L << (MINUS - 107)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (QUOTED_STRING_LITERAL - 194)) | (1L << (STRING_LITERAL - 194)) | (1L << (IntegerLiteral - 194)) | (1L << (FloatingPointLiteral - 194)))) != 0)) {
{
setState(3359);
jsonelements();
}
}
setState(3362);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonelementsContext extends ParserRuleContext {
public List jsonvalue() {
return getRuleContexts(JsonvalueContext.class);
}
public JsonvalueContext jsonvalue(int i) {
return getRuleContext(JsonvalueContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public JsonelementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonelements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonelements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonelements(this);
}
}
public final JsonelementsContext jsonelements() throws RecognitionException {
JsonelementsContext _localctx = new JsonelementsContext(_ctx, getState());
enterRule(_localctx, 520, RULE_jsonelements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3364);
jsonvalue();
setState(3369);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,467,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3365);
match(COMMA);
setState(3366);
jsonvalue();
}
}
}
setState(3371);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,467,_ctx);
}
setState(3373);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(3372);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonmembersContext extends ParserRuleContext {
public List jsonpair() {
return getRuleContexts(JsonpairContext.class);
}
public JsonpairContext jsonpair(int i) {
return getRuleContext(JsonpairContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public JsonmembersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonmembers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonmembers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonmembers(this);
}
}
public final JsonmembersContext jsonmembers() throws RecognitionException {
JsonmembersContext _localctx = new JsonmembersContext(_ctx, getState());
enterRule(_localctx, 522, RULE_jsonmembers);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3375);
jsonpair();
setState(3380);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,469,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3376);
match(COMMA);
setState(3377);
jsonpair();
}
}
}
setState(3382);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,469,_ctx);
}
setState(3384);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(3383);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonpairContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public JsonvalueContext jsonvalue() {
return getRuleContext(JsonvalueContext.class,0);
}
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public JsonpairContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonpair; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonpair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonpair(this);
}
}
public final JsonpairContext jsonpair() throws RecognitionException {
JsonpairContext _localctx = new JsonpairContext(_ctx, getState());
enterRule(_localctx, 524, RULE_jsonpair);
try {
enterOuterAlt(_localctx, 1);
{
setState(3388);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
{
setState(3386);
stringconstant();
}
break;
case WINDOW:
case BETWEEN:
case ESCAPE:
case EVERY_EXPR:
case WHERE:
case SUM:
case AVG:
case MAX:
case MIN:
case COALESCE:
case MEDIAN:
case STDDEV:
case AVEDEV:
case COUNT:
case OUTER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case EVENTS:
case FIRST:
case LAST:
case SCHEMA:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case PATTERN:
case SQL:
case METADATASQL:
case PREVIOUS:
case PREVIOUSTAIL:
case PRIOR:
case WEEKDAY:
case LW:
case INSTANCEOF:
case TYPEOF:
case CAST:
case SNAPSHOT:
case SET:
case VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case DEFINE:
case PARTITION:
case MATCHES:
case AFTER:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case CONTEXT:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(3387);
keywordAllowedIdent();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3390);
match(COLON);
setState(3391);
jsonvalue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
private static final int _serializedATNSegments = 2;
private static final String _serializedATNSegment0 =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00c9\u0d44\4\2\t"+
"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+
"\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+
"\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+
"\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+
"\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+
"\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+
"\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+
"\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+
"\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+
"\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+
"\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+
"\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+
"\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+
"\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+
"\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+
"\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+
"\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+
"\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+
"\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+
"\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1"+
"\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5"+
"\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa"+
"\t\u00fa\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe"+
"\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101\4\u0102\t\u0102\4\u0103"+
"\t\u0103\4\u0104\t\u0104\4\u0105\t\u0105\4\u0106\t\u0106\4\u0107\t\u0107"+
"\4\u0108\t\u0108\3\2\3\2\3\2\7\2\u0214\n\2\f\2\16\2\u0217\13\2\3\2\3\2"+
"\3\2\3\3\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\5\6\u0229\n\6"+
"\3\6\5\6\u022c\n\6\3\6\5\6\u022f\n\6\3\6\3\6\3\6\5\6\u0234\n\6\3\6\5\6"+
"\u0237\n\6\3\6\3\6\5\6\u023b\n\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\5\b\u0244"+
"\n\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u024d\n\b\3\t\3\t\3\t\3\t\3\t\5\t"+
"\u0254\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\5"+
"\13\u0263\n\13\3\13\5\13\u0266\n\13\3\f\3\f\3\f\7\f\u026b\n\f\f\f\16\f"+
"\u026e\13\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\5\16\u0279\n\16\3"+
"\17\3\17\3\17\3\17\7\17\u027f\n\17\f\17\16\17\u0282\13\17\5\17\u0284\n"+
"\17\3\17\5\17\u0287\n\17\3\17\3\17\3\20\5\20\u028c\n\20\3\20\3\20\3\20"+
"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u029d"+
"\n\20\3\20\5\20\u02a0\n\20\3\21\3\21\3\21\3\22\3\22\5\22\u02a7\n\22\3"+
"\22\3\22\5\22\u02ab\n\22\3\22\3\22\3\22\3\22\5\22\u02b1\n\22\3\22\5\22"+
"\u02b4\n\22\3\22\3\22\5\22\u02b8\n\22\3\22\3\22\3\22\5\22\u02bd\n\22\3"+
"\22\3\22\5\22\u02c1\n\22\3\22\3\22\5\22\u02c5\n\22\3\22\3\22\3\22\5\22"+
"\u02ca\n\22\3\22\3\22\5\22\u02ce\n\22\3\23\3\23\3\23\3\23\3\23\6\23\u02d5"+
"\n\23\r\23\16\23\u02d6\3\23\5\23\u02da\n\23\5\23\u02dc\n\23\3\23\3\23"+
"\3\23\5\23\u02e1\n\23\3\24\3\24\5\24\u02e5\n\24\3\24\3\24\3\24\5\24\u02ea"+
"\n\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\5\26\u02f4\n\26\3\26\3\26"+
"\3\26\3\26\5\26\u02fa\n\26\3\27\3\27\5\27\u02fe\n\27\3\27\3\27\3\27\3"+
"\27\5\27\u0304\n\27\3\27\3\27\3\27\5\27\u0309\n\27\3\27\6\27\u030c\n\27"+
"\r\27\16\27\u030d\5\27\u0310\n\27\3\30\3\30\5\30\u0314\n\30\3\31\3\31"+
"\3\31\3\31\5\31\u031a\n\31\3\31\6\31\u031d\n\31\r\31\16\31\u031e\3\32"+
"\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u0328\n\32\3\32\3\32\3\32\5\32\u032d"+
"\n\32\3\32\5\32\u0330\n\32\3\33\3\33\3\33\3\33\3\33\5\33\u0337\n\33\3"+
"\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\5\34\u0341\n\34\3\34\6\34\u0344"+
"\n\34\r\34\16\34\u0345\3\35\3\35\3\35\3\36\3\36\3\36\5\36\u034e\n\36\3"+
"\36\3\36\3\36\3\36\5\36\u0354\n\36\3\36\5\36\u0357\n\36\3\36\3\36\3\36"+
"\3\36\5\36\u035d\n\36\3\37\3\37\5\37\u0361\n\37\3\37\3\37\5\37\u0365\n"+
"\37\3\37\5\37\u0368\n\37\3\37\5\37\u036b\n\37\3\37\3\37\5\37\u036f\n\37"+
"\3\37\3\37\5\37\u0373\n\37\3\37\3\37\3\37\5\37\u0378\n\37\3\37\3\37\5"+
"\37\u037c\n\37\3\37\3\37\3\37\5\37\u0381\n\37\3\37\3\37\5\37\u0385\n\37"+
"\3 \3 \3 \3 \3 \5 \u038c\n \3 \3 \3 \3 \5 \u0392\n \3!\3!\3!\3!\3!\5!"+
"\u0399\n!\3!\3!\5!\u039d\n!\3\"\3\"\3\"\3\"\3\"\5\"\u03a4\n\"\3#\3#\3"+
"#\5#\u03a9\n#\3$\3$\3$\3$\5$\u03af\n$\3%\3%\3%\3&\3&\3&\7&\u03b7\n&\f"+
"&\16&\u03ba\13&\3\'\3\'\3\'\3\'\3\'\5\'\u03c1\n\'\3(\3(\3(\3(\3(\5(\u03c8"+
"\n(\3)\3)\3)\3)\5)\u03ce\n)\3)\3)\5)\u03d2\n)\3)\5)\u03d5\n)\3)\3)\3)"+
"\3)\3)\5)\u03dc\n)\3)\3)\3)\5)\u03e1\n)\5)\u03e3\n)\3*\3*\3*\3*\5*\u03e9"+
"\n*\3*\3*\3+\3+\5+\u03ef\n+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\7,\u03fc"+
"\n,\f,\16,\u03ff\13,\3-\3-\3-\5-\u0404\n-\3-\5-\u0407\n-\3-\3-\3-\5-\u040c"+
"\n-\3-\5-\u040f\n-\5-\u0411\n-\3.\3.\5.\u0415\n.\3.\3.\3.\3.\3.\5.\u041c"+
"\n.\3/\3/\3/\3/\5/\u0422\n/\3/\3/\3/\3/\3\60\3\60\3\60\7\60\u042b\n\60"+
"\f\60\16\60\u042e\13\60\3\61\3\61\3\61\3\61\5\61\u0434\n\61\3\61\5\61"+
"\u0437\n\61\3\61\5\61\u043a\n\61\3\61\3\61\7\61\u043e\n\61\f\61\16\61"+
"\u0441\13\61\3\62\3\62\3\62\7\62\u0446\n\62\f\62\16\62\u0449\13\62\3\63"+
"\3\63\3\63\5\63\u044e\n\63\3\64\3\64\3\64\7\64\u0453\n\64\f\64\16\64\u0456"+
"\13\64\3\65\3\65\3\65\3\65\5\65\u045c\n\65\3\65\3\65\3\65\3\65\5\65\u0462"+
"\n\65\3\66\3\66\5\66\u0466\n\66\3\66\3\66\3\67\3\67\3\67\5\67\u046d\n"+
"\67\3\67\3\67\3\67\5\67\u0472\n\67\3\67\5\67\u0475\n\67\3\67\7\67\u0478"+
"\n\67\f\67\16\67\u047b\13\67\38\38\38\38\38\38\58\u0483\n8\38\38\58\u0487"+
"\n8\39\39\39\3:\3:\3:\3:\3:\3:\7:\u0492\n:\f:\16:\u0495\13:\3;\3;\3;\3"+
";\3<\3<\3<\3<\5<\u049f\n<\3<\3<\3=\3=\7=\u04a5\n=\f=\16=\u04a8\13=\3>"+
"\7>\u04ab\n>\f>\16>\u04ae\13>\3>\3>\5>\u04b2\n>\3>\5>\u04b5\n>\3>\5>\u04b8"+
"\n>\3>\3>\5>\u04bc\n>\3>\5>\u04bf\n>\3>\3>\3>\3>\5>\u04c5\n>\3?\3?\3?"+
"\3?\3@\3@\3@\7@\u04ce\n@\f@\16@\u04d1\13@\3A\3A\5A\u04d5\nA\3A\5A\u04d8"+
"\nA\3B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3D\3D\3D\3D\7D\u04e8\nD\fD\16D\u04eb"+
"\13D\3E\3E\5E\u04ef\nE\3F\3F\3F\3F\7F\u04f5\nF\fF\16F\u04f8\13F\3F\3F"+
"\3G\3G\5G\u04fe\nG\3H\3H\5H\u0502\nH\3I\3I\3I\7I\u0507\nI\fI\16I\u050a"+
"\13I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u0517\nJ\5J\u0519\nJ\3K\3K\3"+
"K\3K\5K\u051f\nK\3K\3K\3L\3L\3L\3M\3M\3M\3N\3N\3N\3N\3N\3N\7N\u052f\n"+
"N\fN\16N\u0532\13N\5N\u0534\nN\3O\3O\3O\5O\u0539\nO\3O\3O\3P\3P\3P\3P"+
"\5P\u0541\nP\3P\3P\5P\u0545\nP\3P\3P\5P\u0549\nP\3P\5P\u054c\nP\3P\3P"+
"\3P\5P\u0551\nP\3P\3P\3P\5P\u0556\nP\3P\5P\u0559\nP\3P\3P\5P\u055d\nP"+
"\3P\3P\3P\7P\u0562\nP\fP\16P\u0565\13P\3P\5P\u0568\nP\3P\5P\u056b\nP\3"+
"P\3P\3P\7P\u0570\nP\fP\16P\u0573\13P\3P\3P\3P\3P\3P\5P\u057a\nP\3P\3P"+
"\3P\7P\u057f\nP\fP\16P\u0582\13P\3P\3P\3P\5P\u0587\nP\5P\u0589\nP\3Q\3"+
"Q\3Q\5Q\u058e\nQ\3Q\3Q\3R\3R\3R\3R\5R\u0596\nR\3R\5R\u0599\nR\3R\5R\u059c"+
"\nR\3R\3R\3R\5R\u05a1\nR\3S\3S\5S\u05a5\nS\3S\5S\u05a8\nS\3T\3T\3T\7T"+
"\u05ad\nT\fT\16T\u05b0\13T\3T\3T\3T\5T\u05b5\nT\3T\5T\u05b8\nT\3U\3U\3"+
"U\3U\3V\3V\5V\u05c0\nV\3V\3V\3V\3V\3W\3W\5W\u05c8\nW\3W\3W\3W\7W\u05cd"+
"\nW\fW\16W\u05d0\13W\3X\3X\5X\u05d4\nX\3X\3X\3Y\3Y\3Y\3Z\3Z\3Z\7Z\u05de"+
"\nZ\fZ\16Z\u05e1\13Z\3[\3[\5[\u05e5\n[\3\\\3\\\3\\\3]\3]\3]\5]\u05ed\n"+
"]\3]\3]\3]\3]\5]\u05f3\n]\3]\5]\u05f6\n]\3]\5]\u05f9\n]\3^\3^\3^\3^\3"+
"^\3_\3_\3_\7_\u0603\n_\f_\16_\u0606\13_\3`\3`\3`\7`\u060b\n`\f`\16`\u060e"+
"\13`\3a\3a\3a\5a\u0613\na\3b\3b\7b\u0617\nb\fb\16b\u061a\13b\3c\3c\7c"+
"\u061e\nc\fc\16c\u0621\13c\3d\3d\3d\5d\u0626\nd\3d\5d\u0629\nd\3d\5d\u062c"+
"\nd\3d\3d\3d\5d\u0631\nd\3e\3e\3e\3e\7e\u0637\ne\fe\16e\u063a\13e\3f\3"+
"f\3f\3f\3g\3g\3h\3h\3h\5h\u0645\nh\3h\5h\u0648\nh\3h\3h\3i\3i\3i\7i\u064f"+
"\ni\fi\16i\u0652\13i\3j\3j\3j\5j\u0657\nj\3k\3k\5k\u065b\nk\3k\5k\u065e"+
"\nk\3k\5k\u0661\nk\3l\3l\3l\3m\3m\3m\3m\3m\5m\u066b\nm\3n\3n\3n\3n\5n"+
"\u0671\nn\3n\5n\u0674\nn\3n\3n\3n\5n\u0679\nn\3n\5n\u067c\nn\3n\3n\5n"+
"\u0680\nn\3o\3o\3o\3o\5o\u0686\no\3o\5o\u0689\no\3p\3p\7p\u068d\np\fp"+
"\16p\u0690\13p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3q\5q\u069c\nq\3q\3q\3q\5q\u06a1"+
"\nq\5q\u06a3\nq\3q\3q\3r\3r\3r\3r\3r\5r\u06ac\nr\3r\5r\u06af\nr\3r\5r"+
"\u06b2\nr\3s\3s\3s\3s\7s\u06b8\ns\fs\16s\u06bb\13s\3s\3s\3s\3s\7s\u06c1"+
"\ns\fs\16s\u06c4\13s\5s\u06c6\ns\3t\3t\3t\3t\3u\3u\5u\u06ce\nu\3u\3u\3"+
"v\3v\5v\u06d4\nv\3v\3v\5v\u06d8\nv\3v\5v\u06db\nv\3w\3w\3w\7w\u06e0\n"+
"w\fw\16w\u06e3\13w\3x\3x\3x\5x\u06e8\nx\3y\3y\3y\3y\3y\7y\u06ef\ny\fy"+
"\16y\u06f2\13y\3y\3y\3z\3z\3z\3z\3z\3z\7z\u06fc\nz\fz\16z\u06ff\13z\3"+
"z\3z\3{\3{\5{\u0705\n{\3|\3|\3|\3|\3|\7|\u070c\n|\f|\16|\u070f\13|\5|"+
"\u0711\n|\3|\5|\u0714\n|\3}\3}\3}\7}\u0719\n}\f}\16}\u071c\13}\3~\3~\3"+
"~\5~\u0721\n~\3\177\3\177\3\u0080\5\u0080\u0726\n\u0080\3\u0080\3\u0080"+
"\3\u0080\3\u0080\5\u0080\u072c\n\u0080\3\u0080\3\u0080\3\u0080\3\u0080"+
"\5\u0080\u0732\n\u0080\3\u0080\5\u0080\u0735\n\u0080\3\u0080\3\u0080\3"+
"\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u073d\n\u0080\3\u0080\3\u0080\3"+
"\u0080\3\u0080\5\u0080\u0743\n\u0080\3\u0080\3\u0080\5\u0080\u0747\n\u0080"+
"\3\u0080\5\u0080\u074a\n\u0080\3\u0080\5\u0080\u074d\n\u0080\3\u0081\3"+
"\u0081\3\u0081\3\u0081\3\u0081\5\u0081\u0754\n\u0081\3\u0081\3\u0081\5"+
"\u0081\u0758\n\u0081\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\5\u0082\u075f"+
"\n\u0082\3\u0083\3\u0083\5\u0083\u0763\n\u0083\3\u0083\3\u0083\5\u0083"+
"\u0767\n\u0083\3\u0083\3\u0083\5\u0083\u076b\n\u0083\5\u0083\u076d\n\u0083"+
"\3\u0084\3\u0084\3\u0084\7\u0084\u0772\n\u0084\f\u0084\16\u0084\u0775"+
"\13\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086"+
"\3\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\5\u0088\u0786"+
"\n\u0088\3\u0088\3\u0088\5\u0088\u078a\n\u0088\3\u0088\5\u0088\u078d\n"+
"\u0088\3\u0088\3\u0088\5\u0088\u0791\n\u0088\3\u0088\5\u0088\u0794\n\u0088"+
"\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\7\u0089\u079d"+
"\n\u0089\f\u0089\16\u0089\u07a0\13\u0089\3\u008a\3\u008a\3\u008a\3\u008a"+
"\7\u008a\u07a6\n\u008a\f\u008a\16\u008a\u07a9\13\u008a\3\u008b\3\u008b"+
"\3\u008b\5\u008b\u07ae\n\u008b\5\u008b\u07b0\n\u008b\3\u008c\3\u008c\3"+
"\u008c\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e"+
"\3\u008e\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f"+
"\u07c5\n\u008f\3\u0090\3\u0090\3\u0090\7\u0090\u07ca\n\u0090\f\u0090\16"+
"\u0090\u07cd\13\u0090\3\u0091\6\u0091\u07d0\n\u0091\r\u0091\16\u0091\u07d1"+
"\3\u0092\3\u0092\3\u0092\5\u0092\u07d7\n\u0092\3\u0093\3\u0093\3\u0093"+
"\3\u0093\3\u0093\3\u0093\5\u0093\u07df\n\u0093\3\u0093\5\u0093\u07e2\n"+
"\u0093\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\7\u0094\u07e9\n\u0094\f"+
"\u0094\16\u0094\u07ec\13\u0094\3\u0094\3\u0094\3\u0095\3\u0095\3\u0095"+
"\3\u0095\5\u0095\u07f4\n\u0095\3\u0095\5\u0095\u07f7\n\u0095\5\u0095\u07f9"+
"\n\u0095\3\u0095\5\u0095\u07fc\n\u0095\3\u0096\3\u0096\5\u0096\u0800\n"+
"\u0096\3\u0096\5\u0096\u0803\n\u0096\3\u0096\5\u0096\u0806\n\u0096\3\u0096"+
"\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\7\u0097\u080e\n\u0097\f\u0097"+
"\16\u0097\u0811\13\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099"+
"\3\u009a\3\u009a\3\u009a\6\u009a\u081c\n\u009a\r\u009a\16\u009a\u081d"+
"\3\u009a\5\u009a\u0821\n\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a"+
"\3\u009a\3\u009a\6\u009a\u082a\n\u009a\r\u009a\16\u009a\u082b\3\u009a"+
"\5\u009a\u082f\n\u009a\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u0835\n"+
"\u009a\3\u009b\3\u009b\3\u009b\7\u009b\u083a\n\u009b\f\u009b\16\u009b"+
"\u083d\13\u009b\3\u009c\3\u009c\3\u009c\7\u009c\u0842\n\u009c\f\u009c"+
"\16\u009c\u0845\13\u009c\3\u009d\3\u009d\3\u009d\7\u009d\u084a\n\u009d"+
"\f\u009d\16\u009d\u084d\13\u009d\3\u009e\3\u009e\3\u009e\5\u009e\u0852"+
"\n\u009e\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\5\u009f"+
"\u085b\n\u009f\3\u009f\3\u009f\3\u009f\3\u009f\5\u009f\u0861\n\u009f\3"+
"\u009f\3\u009f\5\u009f\u0865\n\u009f\3\u009f\3\u009f\5\u009f\u0869\n\u009f"+
"\5\u009f\u086b\n\u009f\7\u009f\u086d\n\u009f\f\u009f\16\u009f\u0870\13"+
"\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0877\n\u00a0\3"+
"\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u087d\n\u00a0\3\u00a0\3\u00a0\5"+
"\u00a0\u0881\n\u00a0\3\u00a0\3\u00a0\5\u00a0\u0885\n\u00a0\5\u00a0\u0887"+
"\n\u00a0\7\u00a0\u0889\n\u00a0\f\u00a0\16\u00a0\u088c\13\u00a0\3\u00a0"+
"\5\u00a0\u088f\n\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0894\n\u00a0\3"+
"\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\7\u00a0\u089b\n\u00a0\f\u00a0\16"+
"\u00a0\u089e\13\u00a0\5\u00a0\u08a0\n\u00a0\3\u00a0\3\u00a0\5\u00a0\u08a4"+
"\n\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0"+
"\5\u00a0\u08ae\n\u00a0\3\u00a0\3\u00a0\5\u00a0\u08b2\n\u00a0\5\u00a0\u08b4"+
"\n\u00a0\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\7\u00a2"+
"\u08bd\n\u00a2\f\u00a2\16\u00a2\u08c0\13\u00a2\5\u00a2\u08c2\n\u00a2\3"+
"\u00a3\3\u00a3\3\u00a3\7\u00a3\u08c7\n\u00a3\f\u00a3\16\u00a3\u08ca\13"+
"\u00a3\3\u00a4\3\u00a4\3\u00a4\7\u00a4\u08cf\n\u00a4\f\u00a4\16\u00a4"+
"\u08d2\13\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5"+
"\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5"+
"\3\u00a5\3\u00a5\7\u00a5\u08e6\n\u00a5\f\u00a5\16\u00a5\u08e9\13\u00a5"+
"\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\7\u00a5"+
"\u08f3\n\u00a5\f\u00a5\16\u00a5\u08f6\13\u00a5\5\u00a5\u08f8\n\u00a5\3"+
"\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5"+
"\3\u00a5\5\u00a5\u0904\n\u00a5\3\u00a5\5\u00a5\u0907\n\u00a5\3\u00a5\3"+
"\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\5\u00a5\u090f\n\u00a5\3\u00a5\3"+
"\u00a5\3\u00a5\5\u00a5\u0914\n\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3"+
"\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u091f\n\u00a8\3\u00a9\3"+
"\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac"+
"\3\u00ac\5\u00ac\u092c\n\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac"+
"\5\u00ac\u0933\n\u00ac\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0938\n\u00ac\3"+
"\u00ac\3\u00ac\5\u00ac\u093c\n\u00ac\3\u00ac\3\u00ac\3\u00ad\3\u00ad\5"+
"\u00ad\u0942\n\u00ad\3\u00ad\3\u00ad\3\u00ad\5\u00ad\u0947\n\u00ad\3\u00ad"+
"\3\u00ad\5\u00ad\u094b\n\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae\7\u00ae"+
"\u0951\n\u00ae\f\u00ae\16\u00ae\u0954\13\u00ae\5\u00ae\u0956\n\u00ae\3"+
"\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af\3\u00af\5\u00af\u095e\n\u00af\3"+
"\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u0966\n\u00af\3"+
"\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u096f\n"+
"\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u0977\n"+
"\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u097f\n"+
"\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u0987\n"+
"\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\7\u00af\u0994\n\u00af\f\u00af\16\u00af\u0997"+
"\13\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af"+
"\u09a0\n\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\5\u00af\u09aa\n\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\7\u00af\u09d2\n\u00af"+
"\f\u00af\16\u00af\u09d5\13\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\5\u00af\u09e5\n\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u09f2\n\u00af\3\u00af"+
"\3\u00af\3\u00af\3\u00af\5\u00af\u09f8\n\u00af\3\u00b0\3\u00b0\3\u00b0"+
"\5\u00b0\u09fd\n\u00b0\3\u00b0\3\u00b0\5\u00b0\u0a01\n\u00b0\3\u00b0\3"+
"\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1\5\u00b1\u0a09\n\u00b1\3\u00b1\5"+
"\u00b1\u0a0c\n\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3"+
"\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u0a18\n\u00b2\3\u00b3\5\u00b3\u0a1b"+
"\n\u00b3\3\u00b3\3\u00b3\3\u00b3\7\u00b3\u0a20\n\u00b3\f\u00b3\16\u00b3"+
"\u0a23\13\u00b3\3\u00b4\5\u00b4\u0a26\n\u00b4\3\u00b4\3\u00b4\3\u00b5"+
"\3\u00b5\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b7\3\u00b7\7\u00b7\u0a32"+
"\n\u00b7\f\u00b7\16\u00b7\u0a35\13\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8"+
"\3\u00b8\3\u00b8\5\u00b8\u0a3d\n\u00b8\3\u00b8\3\u00b8\3\u00b9\3\u00b9"+
"\3\u00b9\7\u00b9\u0a44\n\u00b9\f\u00b9\16\u00b9\u0a47\13\u00b9\3\u00ba"+
"\3\u00ba\3\u00ba\7\u00ba\u0a4c\n\u00ba\f\u00ba\16\u00ba\u0a4f\13\u00ba"+
"\3\u00bb\5\u00bb\u0a52\n\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb\u0a57\n"+
"\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0a5d\n\u00bc\3\u00bc\5"+
"\u00bc\u0a60\n\u00bc\5\u00bc\u0a62\n\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd"+
"\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u0a6b\n\u00bd\3\u00bd\3\u00bd\3\u00bd"+
"\3\u00bd\5\u00bd\u0a71\n\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\7\u00be"+
"\u0a77\n\u00be\f\u00be\16\u00be\u0a7a\13\u00be\3\u00be\3\u00be\3\u00bf"+
"\3\u00bf\3\u00c0\3\u00c0\5\u00c0\u0a82\n\u00c0\3\u00c1\3\u00c1\3\u00c1"+
"\3\u00c1\5\u00c1\u0a88\n\u00c1\3\u00c1\3\u00c1\5\u00c1\u0a8c\n\u00c1\3"+
"\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\5\u00c2\u0a95\n"+
"\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\5\u00c4\u0aa1\n\u00c4\5\u00c4\u0aa3\n\u00c4\3\u00c4\3"+
"\u00c4\5\u00c4\u0aa7\n\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5\5\u00c5\u0aad"+
"\n\u00c5\3\u00c5\3\u00c5\3\u00c5\5\u00c5\u0ab2\n\u00c5\3\u00c5\5\u00c5"+
"\u0ab5\n\u00c5\3\u00c5\5\u00c5\u0ab8\n\u00c5\3\u00c6\3\u00c6\7\u00c6\u0abc"+
"\n\u00c6\f\u00c6\16\u00c6\u0abf\13\u00c6\3\u00c7\3\u00c7\5\u00c7\u0ac3"+
"\n\u00c7\3\u00c7\3\u00c7\5\u00c7\u0ac7\n\u00c7\3\u00c7\3\u00c7\5\u00c7"+
"\u0acb\n\u00c7\3\u00c7\3\u00c7\5\u00c7\u0acf\n\u00c7\3\u00c7\3\u00c7\3"+
"\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\7\u00c9\u0ada\n"+
"\u00c9\f\u00c9\16\u00c9\u0add\13\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+
"\3\u00ca\5\u00ca\u0ae4\n\u00ca\5\u00ca\u0ae6\n\u00ca\3\u00cb\3\u00cb\3"+
"\u00cb\3\u00cb\3\u00cb\5\u00cb\u0aed\n\u00cb\3\u00cc\3\u00cc\3\u00cc\3"+
"\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd\5\u00cd\u0af7\n\u00cd\3\u00cd\3"+
"\u00cd\3\u00cd\5\u00cd\u0afc\n\u00cd\3\u00cd\5\u00cd\u0aff\n\u00cd\3\u00cd"+
"\5\u00cd\u0b02\n\u00cd\3\u00cd\5\u00cd\u0b05\n\u00cd\3\u00ce\3\u00ce\3"+
"\u00ce\3\u00ce\3\u00ce\3\u00ce\5\u00ce\u0b0d\n\u00ce\3\u00cf\3\u00cf\5"+
"\u00cf\u0b11\n\u00cf\3\u00d0\3\u00d0\5\u00d0\u0b15\n\u00d0\3\u00d0\7\u00d0"+
"\u0b18\n\u00d0\f\u00d0\16\u00d0\u0b1b\13\u00d0\3\u00d1\3\u00d1\3\u00d1"+
"\3\u00d1\7\u00d1\u0b21\n\u00d1\f\u00d1\16\u00d1\u0b24\13\u00d1\3\u00d1"+
"\3\u00d1\3\u00d2\3\u00d2\5\u00d2\u0b2a\n\u00d2\3\u00d2\3\u00d2\3\u00d3"+
"\3\u00d3\3\u00d3\7\u00d3\u0b31\n\u00d3\f\u00d3\16\u00d3\u0b34\13\u00d3"+
"\3\u00d4\3\u00d4\3\u00d4\7\u00d4\u0b39\n\u00d4\f\u00d4\16\u00d4\u0b3c"+
"\13\u00d4\3\u00d5\3\u00d5\3\u00d5\7\u00d5\u0b41\n\u00d5\f\u00d5\16\u00d5"+
"\u0b44\13\u00d5\3\u00d6\3\u00d6\5\u00d6\u0b48\n\u00d6\3\u00d7\3\u00d7"+
"\5\u00d7\u0b4c\n\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\5\u00d8"+
"\u0b53\n\u00d8\3\u00d8\5\u00d8\u0b56\n\u00d8\3\u00d9\3\u00d9\3\u00d9\3"+
"\u00d9\3\u00d9\5\u00d9\u0b5d\n\u00d9\3\u00d9\5\u00d9\u0b60\n\u00d9\3\u00da"+
"\3\u00da\3\u00da\7\u00da\u0b65\n\u00da\f\u00da\16\u00da\u0b68\13\u00da"+
"\3\u00db\3\u00db\3\u00db\7\u00db\u0b6d\n\u00db\f\u00db\16\u00db\u0b70"+
"\13\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc"+
"\3\u00dc\3\u00dc\5\u00dc\u0b7c\n\u00dc\3\u00dd\3\u00dd\5\u00dd\u0b80\n"+
"\u00dd\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\5\u00de\u0b88\n"+
"\u00de\3\u00df\3\u00df\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\3\u00e1"+
"\3\u00e1\5\u00e1\u0b93\n\u00e1\3\u00e2\3\u00e2\3\u00e2\5\u00e2\u0b98\n"+
"\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\5\u00e2\u0b9e\n\u00e2\3\u00e3\3"+
"\u00e3\3\u00e3\5\u00e3\u0ba3\n\u00e3\3\u00e3\3\u00e3\3\u00e4\3\u00e4\3"+
"\u00e4\5\u00e4\u0baa\n\u00e4\3\u00e4\3\u00e4\3\u00e5\3\u00e5\3\u00e5\3"+
"\u00e5\7\u00e5\u0bb2\n\u00e5\f\u00e5\16\u00e5\u0bb5\13\u00e5\3\u00e5\3"+
"\u00e5\3\u00e6\3\u00e6\3\u00e6\5\u00e6\u0bbc\n\u00e6\3\u00e7\3\u00e7\3"+
"\u00e7\3\u00e8\3\u00e8\5\u00e8\u0bc3\n\u00e8\3\u00e9\7\u00e9\u0bc6\n\u00e9"+
"\f\u00e9\16\u00e9\u0bc9\13\u00e9\3\u00ea\3\u00ea\5\u00ea\u0bcd\n\u00ea"+
"\3\u00eb\3\u00eb\3\u00eb\5\u00eb\u0bd2\n\u00eb\3\u00ec\3\u00ec\3\u00ec"+
"\3\u00ec\7\u00ec\u0bd8\n\u00ec\f\u00ec\16\u00ec\u0bdb\13\u00ec\3\u00ec"+
"\3\u00ec\3\u00ed\3\u00ed\3\u00ed\5\u00ed\u0be2\n\u00ed\3\u00ed\5\u00ed"+
"\u0be5\n\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\5\u00ee\u0beb\n\u00ee\7"+
"\u00ee\u0bed\n\u00ee\f\u00ee\16\u00ee\u0bf0\13\u00ee\3\u00ef\3\u00ef\5"+
"\u00ef\u0bf4\n\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3"+
"\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
"\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
"\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
"\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
"\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
"\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\5\u00f0\u0c2e\n\u00f0\3\u00f1"+
"\3\u00f1\3\u00f1\5\u00f1\u0c33\n\u00f1\3\u00f2\3\u00f2\5\u00f2\u0c37\n"+
"\u00f2\3\u00f3\3\u00f3\5\u00f3\u0c3b\n\u00f3\3\u00f3\5\u00f3\u0c3e\n\u00f3"+
"\3\u00f3\5\u00f3\u0c41\n\u00f3\3\u00f3\5\u00f3\u0c44\n\u00f3\3\u00f3\5"+
"\u00f3\u0c47\n\u00f3\3\u00f3\5\u00f3\u0c4a\n\u00f3\3\u00f3\5\u00f3\u0c4d"+
"\n\u00f3\3\u00f3\5\u00f3\u0c50\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0c54\n"+
"\u00f3\3\u00f3\5\u00f3\u0c57\n\u00f3\3\u00f3\5\u00f3\u0c5a\n\u00f3\3\u00f3"+
"\5\u00f3\u0c5d\n\u00f3\3\u00f3\5\u00f3\u0c60\n\u00f3\3\u00f3\5\u00f3\u0c63"+
"\n\u00f3\3\u00f3\5\u00f3\u0c66\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0c6a\n"+
"\u00f3\3\u00f3\5\u00f3\u0c6d\n\u00f3\3\u00f3\5\u00f3\u0c70\n\u00f3\3\u00f3"+
"\5\u00f3\u0c73\n\u00f3\3\u00f3\5\u00f3\u0c76\n\u00f3\3\u00f3\5\u00f3\u0c79"+
"\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0c7d\n\u00f3\3\u00f3\5\u00f3\u0c80\n"+
"\u00f3\3\u00f3\5\u00f3\u0c83\n\u00f3\3\u00f3\5\u00f3\u0c86\n\u00f3\3\u00f3"+
"\5\u00f3\u0c89\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0c8d\n\u00f3\3\u00f3\5"+
"\u00f3\u0c90\n\u00f3\3\u00f3\5\u00f3\u0c93\n\u00f3\3\u00f3\5\u00f3\u0c96"+
"\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0c9a\n\u00f3\3\u00f3\5\u00f3\u0c9d\n"+
"\u00f3\3\u00f3\5\u00f3\u0ca0\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0ca4\n\u00f3"+
"\3\u00f3\5\u00f3\u0ca7\n\u00f3\3\u00f3\3\u00f3\5\u00f3\u0cab\n\u00f3\3"+
"\u00f3\5\u00f3\u0cae\n\u00f3\3\u00f4\3\u00f4\3\u00f4\5\u00f4\u0cb3\n\u00f4"+
"\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3\u00f5\5\u00f5\u0cba\n\u00f5\3\u00f5"+
"\3\u00f5\3\u00f6\3\u00f6\3\u00f6\5\u00f6\u0cc1\n\u00f6\3\u00f6\3\u00f6"+
"\3\u00f7\3\u00f7\3\u00f7\5\u00f7\u0cc8\n\u00f7\3\u00f7\3\u00f7\3\u00f8"+
"\3\u00f8\3\u00f8\5\u00f8\u0ccf\n\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9"+
"\3\u00f9\5\u00f9\u0cd6\n\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa"+
"\5\u00fa\u0cdd\n\u00fa\3\u00fa\3\u00fa\3\u00fb\3\u00fb\3\u00fb\5\u00fb"+
"\u0ce4\n\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\5\u00fc\u0ceb\n"+
"\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd\3\u00fe\3\u00fe\3\u00fe\5\u00fe"+
"\u0cf4\n\u00fe\3\u00fe\3\u00fe\5\u00fe\u0cf8\n\u00fe\5\u00fe\u0cfa\n\u00fe"+
"\3\u00ff\5\u00ff\u0cfd\n\u00ff\3\u00ff\3\u00ff\3\u00ff\7\u00ff\u0d02\n"+
"\u00ff\f\u00ff\16\u00ff\u0d05\13\u00ff\3\u0100\3\u0100\3\u0100\3\u0100"+
"\3\u0100\5\u0100\u0d0c\n\u0100\3\u0101\3\u0101\5\u0101\u0d10\n\u0101\3"+
"\u0101\3\u0101\3\u0102\3\u0102\5\u0102\u0d16\n\u0102\3\u0103\3\u0103\3"+
"\u0103\5\u0103\u0d1b\n\u0103\3\u0104\3\u0104\3\u0104\3\u0104\3\u0105\3"+
"\u0105\5\u0105\u0d23\n\u0105\3\u0105\3\u0105\3\u0106\3\u0106\3\u0106\7"+
"\u0106\u0d2a\n\u0106\f\u0106\16\u0106\u0d2d\13\u0106\3\u0106\5\u0106\u0d30"+
"\n\u0106\3\u0107\3\u0107\3\u0107\7\u0107\u0d35\n\u0107\f\u0107\16\u0107"+
"\u0d38\13\u0107\3\u0107\5\u0107\u0d3b\n\u0107\3\u0108\3\u0108\5\u0108"+
"\u0d3f\n\u0108\3\u0108\3\u0108\3\u0108\3\u0108\2\2\u0109\2\4\6\b\n\f\16"+
"\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd"+
"fhjlnprtvxz|~\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\u00d4\u00d6\u00d8\u00da"+
"\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2"+
"\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a"+
"\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122"+
"\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a"+
"\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152"+
"\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a"+
"\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182"+
"\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194\u0196\u0198\u019a"+
"\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2"+
"\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca"+
"\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de\u01e0\u01e2"+
"\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4\u01f6\u01f8\u01fa"+
"\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\2\25\3\2"+
"\u008e\u008f\4\2\u0090\u0090\u0099\u0099\4\2\13\13\u009a\u009a\3\2\u0087"+
"\u0088\5\2\u00af\u00af\u00b1\u00b1\u00b4\u00b4\4\2\u00a1\u00a1\u00a4\u00a4"+
"\5\2\u009f\u009f\u00a7\u00a7\u00a9\u00a9\3\2,-\4\2\20\20\u009a\u009a\3"+
"\2XY\3\2Z[\3\2\\]\3\2^_\3\2`a\4\2\24\24bc\3\2df\3\2gi\3\2jl\3\2\u00c8"+
"\u00c9\2\u0ee7\2\u0215\3\2\2\2\4\u021b\3\2\2\2\6\u021e\3\2\2\2\b\u0221"+
"\3\2\2\2\n\u0226\3\2\2\2\f\u023e\3\2\2\2\16\u024c\3\2\2\2\20\u0253\3\2"+
"\2\2\22\u0257\3\2\2\2\24\u025d\3\2\2\2\26\u0267\3\2\2\2\30\u026f\3\2\2"+
"\2\32\u0278\3\2\2\2\34\u027a\3\2\2\2\36\u028b\3\2\2\2 \u02a1\3\2\2\2\""+
"\u02a6\3\2\2\2$\u02cf\3\2\2\2&\u02e4\3\2\2\2(\u02eb\3\2\2\2*\u02ef\3\2"+
"\2\2,\u02fb\3\2\2\2.\u0313\3\2\2\2\60\u0315\3\2\2\2\62\u0320\3\2\2\2\64"+
"\u0331\3\2\2\2\66\u033b\3\2\2\28\u0347\3\2\2\2:\u034a\3\2\2\2<\u0360\3"+
"\2\2\2>\u0386\3\2\2\2@\u0393\3\2\2\2B\u039e\3\2\2\2D\u03a5\3\2\2\2F\u03aa"+
"\3\2\2\2H\u03b0\3\2\2\2J\u03b3\3\2\2\2L\u03c0\3\2\2\2N\u03c2\3\2\2\2P"+
"\u03c9\3\2\2\2R\u03e8\3\2\2\2T\u03ec\3\2\2\2V\u03f8\3\2\2\2X\u0406\3\2"+
"\2\2Z\u0412\3\2\2\2\\\u041d\3\2\2\2^\u0427\3\2\2\2`\u042f\3\2\2\2b\u0442"+
"\3\2\2\2d\u044a\3\2\2\2f\u044f\3\2\2\2h\u0461\3\2\2\2j\u0463\3\2\2\2l"+
"\u0469\3\2\2\2n\u047c\3\2\2\2p\u0488\3\2\2\2r\u048b\3\2\2\2t\u0496\3\2"+
"\2\2v\u049a\3\2\2\2x\u04a2\3\2\2\2z\u04c4\3\2\2\2|\u04c6\3\2\2\2~\u04ca"+
"\3\2\2\2\u0080\u04d4\3\2\2\2\u0082\u04d9\3\2\2\2\u0084\u04e0\3\2\2\2\u0086"+
"\u04e3\3\2\2\2\u0088\u04ec\3\2\2\2\u008a\u04f0\3\2\2\2\u008c\u04fd\3\2"+
"\2\2\u008e\u04ff\3\2\2\2\u0090\u0503\3\2\2\2\u0092\u0518\3\2\2\2\u0094"+
"\u051a\3\2\2\2\u0096\u0522\3\2\2\2\u0098\u0525\3\2\2\2\u009a\u0533\3\2"+
"\2\2\u009c\u0535\3\2\2\2\u009e\u0588\3\2\2\2\u00a0\u058a\3\2\2\2\u00a2"+
"\u05a0\3\2\2\2\u00a4\u05a2\3\2\2\2\u00a6\u05a9\3\2\2\2\u00a8\u05b9\3\2"+
"\2\2\u00aa\u05bd\3\2\2\2\u00ac\u05c5\3\2\2\2\u00ae\u05d1\3\2\2\2\u00b0"+
"\u05d7\3\2\2\2\u00b2\u05da\3\2\2\2\u00b4\u05e4\3\2\2\2\u00b6\u05e6\3\2"+
"\2\2\u00b8\u05ec\3\2\2\2\u00ba\u05fa\3\2\2\2\u00bc\u05ff\3\2\2\2\u00be"+
"\u0607\3\2\2\2\u00c0\u060f\3\2\2\2\u00c2\u0618\3\2\2\2\u00c4\u061b\3\2"+
"\2\2\u00c6\u062b\3\2\2\2\u00c8\u0632\3\2\2\2\u00ca\u063b\3\2\2\2\u00cc"+
"\u063f\3\2\2\2\u00ce\u0644\3\2\2\2\u00d0\u064b\3\2\2\2\u00d2\u0656\3\2"+
"\2\2\u00d4\u0658\3\2\2\2\u00d6\u0662\3\2\2\2\u00d8\u0665\3\2\2\2\u00da"+
"\u0670\3\2\2\2\u00dc\u0681\3\2\2\2\u00de\u068a\3\2\2\2\u00e0\u0695\3\2"+
"\2\2\u00e2\u06a6\3\2\2\2\u00e4\u06c5\3\2\2\2\u00e6\u06c7\3\2\2\2\u00e8"+
"\u06cd\3\2\2\2\u00ea\u06d3\3\2\2\2\u00ec\u06dc\3\2\2\2\u00ee\u06e7\3\2"+
"\2\2\u00f0\u06e9\3\2\2\2\u00f2\u06f5\3\2\2\2\u00f4\u0704\3\2\2\2\u00f6"+
"\u0713\3\2\2\2\u00f8\u0715\3\2\2\2\u00fa\u071d\3\2\2\2\u00fc\u0722\3\2"+
"\2\2\u00fe\u0725\3\2\2\2\u0100\u074e\3\2\2\2\u0102\u0759\3\2\2\2\u0104"+
"\u0762\3\2\2\2\u0106\u076e\3\2\2\2\u0108\u0776\3\2\2\2\u010a\u077a\3\2"+
"\2\2\u010c\u077f\3\2\2\2\u010e\u0782\3\2\2\2\u0110\u0797\3\2\2\2\u0112"+
"\u07a1\3\2\2\2\u0114\u07aa\3\2\2\2\u0116\u07b1\3\2\2\2\u0118\u07b4\3\2"+
"\2\2\u011a\u07b9\3\2\2\2\u011c\u07c0\3\2\2\2\u011e\u07c6\3\2\2\2\u0120"+
"\u07cf\3\2\2\2\u0122\u07d6\3\2\2\2\u0124\u07d8\3\2\2\2\u0126\u07e3\3\2"+
"\2\2\u0128\u07ef\3\2\2\2\u012a\u07fd\3\2\2\2\u012c\u0809\3\2\2\2\u012e"+
"\u0812\3\2\2\2\u0130\u0816\3\2\2\2\u0132\u0834\3\2\2\2\u0134\u0836\3\2"+
"\2\2\u0136\u083e\3\2\2\2\u0138\u0846\3\2\2\2\u013a\u0851\3\2\2\2\u013c"+
"\u0853\3\2\2\2\u013e\u0871\3\2\2\2\u0140\u08b5\3\2\2\2\u0142\u08b7\3\2"+
"\2\2\u0144\u08c3\3\2\2\2\u0146\u08cb\3\2\2\2\u0148\u0913\3\2\2\2\u014a"+
"\u0915\3\2\2\2\u014c\u0918\3\2\2\2\u014e\u091b\3\2\2\2\u0150\u0920\3\2"+
"\2\2\u0152\u0923\3\2\2\2\u0154\u0925\3\2\2\2\u0156\u0928\3\2\2\2\u0158"+
"\u093f\3\2\2\2\u015a\u094c\3\2\2\2\u015c\u09f7\3\2\2\2\u015e\u09fc\3\2"+
"\2\2\u0160\u0a05\3\2\2\2\u0162\u0a17\3\2\2\2\u0164\u0a1a\3\2\2\2\u0166"+
"\u0a25\3\2\2\2\u0168\u0a29\3\2\2\2\u016a\u0a2d\3\2\2\2\u016c\u0a2f\3\2"+
"\2\2\u016e\u0a3c\3\2\2\2\u0170\u0a40\3\2\2\2\u0172\u0a48\3\2\2\2\u0174"+
"\u0a51\3\2\2\2\u0176\u0a61\3\2\2\2\u0178\u0a6a\3\2\2\2\u017a\u0a72\3\2"+
"\2\2\u017c\u0a7d\3\2\2\2\u017e\u0a81\3\2\2\2\u0180\u0a83\3\2\2\2\u0182"+
"\u0a8f\3\2\2\2\u0184\u0a98\3\2\2\2\u0186\u0a9c\3\2\2\2\u0188\u0aac\3\2"+
"\2\2\u018a\u0ab9\3\2\2\2\u018c\u0ac0\3\2\2\2\u018e\u0ad2\3\2\2\2\u0190"+
"\u0ad6\3\2\2\2\u0192\u0ae5\3\2\2\2\u0194\u0ae7\3\2\2\2\u0196\u0aee\3\2"+
"\2\2\u0198\u0af6\3\2\2\2\u019a\u0b06\3\2\2\2\u019c\u0b0e\3\2\2\2\u019e"+
"\u0b12\3\2\2\2\u01a0\u0b1c\3\2\2\2\u01a2\u0b27\3\2\2\2\u01a4\u0b2d\3\2"+
"\2\2\u01a6\u0b35\3\2\2\2\u01a8\u0b3d\3\2\2\2\u01aa\u0b47\3\2\2\2\u01ac"+
"\u0b4b\3\2\2\2\u01ae\u0b4d\3\2\2\2\u01b0\u0b57\3\2\2\2\u01b2\u0b61\3\2"+
"\2\2\u01b4\u0b69\3\2\2\2\u01b6\u0b7b\3\2\2\2\u01b8\u0b7f\3\2\2\2\u01ba"+
"\u0b81\3\2\2\2\u01bc\u0b89\3\2\2\2\u01be\u0b8b\3\2\2\2\u01c0\u0b8d\3\2"+
"\2\2\u01c2\u0b97\3\2\2\2\u01c4\u0ba2\3\2\2\2\u01c6\u0ba9\3\2\2\2\u01c8"+
"\u0bad\3\2\2\2\u01ca\u0bbb\3\2\2\2\u01cc\u0bbd\3\2\2\2\u01ce\u0bc0\3\2"+
"\2\2\u01d0\u0bc7\3\2\2\2\u01d2\u0bca\3\2\2\2\u01d4\u0bd1\3\2\2\2\u01d6"+
"\u0bd3\3\2\2\2\u01d8\u0bde\3\2\2\2\u01da\u0be6\3\2\2\2\u01dc\u0bf3\3\2"+
"\2\2\u01de\u0c2d\3\2\2\2\u01e0\u0c32\3\2\2\2\u01e2\u0c36\3\2\2\2\u01e4"+
"\u0cad\3\2\2\2\u01e6\u0cb2\3\2\2\2\u01e8\u0cb9\3\2\2\2\u01ea\u0cc0\3\2"+
"\2\2\u01ec\u0cc7\3\2\2\2\u01ee\u0cce\3\2\2\2\u01f0\u0cd5\3\2\2\2\u01f2"+
"\u0cdc\3\2\2\2\u01f4\u0ce3\3\2\2\2\u01f6\u0cea\3\2\2\2\u01f8\u0cee\3\2"+
"\2\2\u01fa\u0cf0\3\2\2\2\u01fc\u0cfc\3\2\2\2\u01fe\u0d0b\3\2\2\2\u0200"+
"\u0d0f\3\2\2\2\u0202\u0d15\3\2\2\2\u0204\u0d1a\3\2\2\2\u0206\u0d1c\3\2"+
"\2\2\u0208\u0d20\3\2\2\2\u020a\u0d26\3\2\2\2\u020c\u0d31\3\2\2\2\u020e"+
"\u0d3e\3\2\2\2\u0210\u0214\5\24\13\2\u0211\u0214\5\n\6\2\u0212\u0214\5"+
"\b\5\2\u0213\u0210\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0212\3\2\2\2\u0214"+
"\u0217\3\2\2\2\u0215\u0213\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0218\3\2"+
"\2\2\u0217\u0215\3\2\2\2\u0218\u0219\5\36\20\2\u0219\u021a\7\2\2\3\u021a"+
"\3\3\2\2\2\u021b\u021c\5\u01cc\u00e7\2\u021c\u021d\7\2\2\3\u021d\5\3\2"+
"\2\2\u021e\u021f\5\u0204\u0103\2\u021f\u0220\7\2\2\3\u0220\7\3\2\2\2\u0221"+
"\u0222\7\u0080\2\2\u0222\u0223\7\u00c6\2\2\u0223\u0224\5\u0202\u0102\2"+
"\u0224\u0225\7\u00c6\2\2\u0225\t\3\2\2\2\u0226\u0228\7\177\2\2\u0227\u0229"+
"\5\u019e\u00d0\2\u0228\u0227\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022b\3"+
"\2\2\2\u022a\u022c\5\u0196\u00cc\2\u022b\u022a\3\2\2\2\u022b\u022c\3\2"+
"\2\2\u022c\u022e\3\2\2\2\u022d\u022f\5\f\7\2\u022e\u022d\3\2\2\2\u022e"+
"\u022f\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0236\7\u00c7\2\2\u0231\u0233"+
"\7\u0093\2\2\u0232\u0234\5\u00bc_\2\u0233\u0232\3\2\2\2\u0233\u0234\3"+
"\2\2\2\u0234\u0235\3\2\2\2\u0235\u0237\7\u0094\2\2\u0236\u0231\3\2\2\2"+
"\u0236\u0237\3\2\2\2\u0237\u023a\3\2\2\2\u0238\u0239\7\u00c7\2\2\u0239"+
"\u023b\7z\2\2\u023a\u0238\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023c\3\2"+
"\2\2\u023c\u023d\5\16\b\2\u023d\13\3\2\2\2\u023e\u023f\7\u00c7\2\2\u023f"+
"\u0240\7\u0099\2\2\u0240\r\3\2\2\2\u0241\u0243\7\u0097\2\2\u0242\u0244"+
"\5\20\t\2\u0243\u0242\3\2\2\2\u0243\u0244\3\2\2\2\u0244\u0245\3\2\2\2"+
"\u0245\u0246\5\u0130\u0099\2\u0246\u0247\7\u0098\2\2\u0247\u024d\3\2\2"+
"\2\u0248\u0249\7\u0095\2\2\u0249\u024a\5\u0202\u0102\2\u024a\u024b\7\u0096"+
"\2\2\u024b\u024d\3\2\2\2\u024c\u0241\3\2\2\2\u024c\u0248\3\2\2\2\u024d"+
"\17\3\2\2\2\u024e\u0254\5\u01de\u00f0\2\u024f\u0250\7\u0093\2\2\u0250"+
"\u0251\5\u00be`\2\u0251\u0252\7\u0094\2\2\u0252\u0254\3\2\2\2\u0253\u024e"+
"\3\2\2\2\u0253\u024f\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0256\t\2\2\2\u0256"+
"\21\3\2\2\2\u0257\u0258\7\u00be\2\2\u0258\u0259\7\u00c7\2\2\u0259\u025a"+
"\7\u0093\2\2\u025a\u025b\7\u00c7\2\2\u025b\u025c\7\u0094\2\2\u025c\23"+
"\3\2\2\2\u025d\u025e\7\u00be\2\2\u025e\u0265\5\u01a4\u00d3\2\u025f\u0262"+
"\7\u0093\2\2\u0260\u0263\5\26\f\2\u0261\u0263\5\32\16\2\u0262\u0260\3"+
"\2\2\2\u0262\u0261\3\2\2\2\u0262\u0263\3\2\2\2\u0263\u0264\3\2\2\2\u0264"+
"\u0266\7\u0094\2\2\u0265\u025f\3\2\2\2\u0265\u0266\3\2\2\2\u0266\25\3"+
"\2\2\2\u0267\u026c\5\30\r\2\u0268\u0269\7\u009a\2\2\u0269\u026b\5\30\r"+
"\2\u026a\u0268\3\2\2\2\u026b\u026e\3\2\2\2\u026c\u026a\3\2\2\2\u026c\u026d"+
"\3\2\2\2\u026d\27\3\2\2\2\u026e\u026c\3\2\2\2\u026f\u0270\5\u01de\u00f0"+
"\2\u0270\u0271\7\u0090\2\2\u0271\u0272\5\32\16\2\u0272\31\3\2\2\2\u0273"+
"\u0279\5\24\13\2\u0274\u0279\5\34\17\2\u0275\u0279\5\u01fe\u0100\2\u0276"+
"\u0279\7\u00c7\2\2\u0277\u0279\5\u01a4\u00d3\2\u0278\u0273\3\2\2\2\u0278"+
"\u0274\3\2\2\2\u0278\u0275\3\2\2\2\u0278\u0276\3\2\2\2\u0278\u0277\3\2"+
"\2\2\u0279\33\3\2\2\2\u027a\u0283\7\u0097\2\2\u027b\u0280\5\32\16\2\u027c"+
"\u027d\7\u009a\2\2\u027d\u027f\5\32\16\2\u027e\u027c\3\2\2\2\u027f\u0282"+
"\3\2\2\2\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0284\3\2\2\2\u0282"+
"\u0280\3\2\2\2\u0283\u027b\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0286\3\2"+
"\2\2\u0285\u0287\7\u009a\2\2\u0286\u0285\3\2\2\2\u0286\u0287\3\2\2\2\u0287"+
"\u0288\3\2\2\2\u0288\u0289\7\u0098\2\2\u0289\35\3\2\2\2\u028a\u028c\5"+
" \21\2\u028b\u028a\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u029c\3\2\2\2\u028d"+
"\u029d\5\"\22\2\u028e\u029d\5P)\2\u028f\u029d\5T+\2\u0290\u029d\5Z.\2"+
"\u0291\u029d\5\\/\2\u0292\u029d\5j\66\2\u0293\u029d\5\u0094K\2\u0294\u029d"+
"\5\u0096L\2\u0295\u029d\5\u0098M\2\u0296\u029d\5$\23\2\u0297\u029d\5("+
"\25\2\u0298\u029d\5v<\2\u0299\u029d\5n8\2\u029a\u029d\5p9\2\u029b\u029d"+
"\5r:\2\u029c\u028d\3\2\2\2\u029c\u028e\3\2\2\2\u029c\u028f\3\2\2\2\u029c"+
"\u0290\3\2\2\2\u029c\u0291\3\2\2\2\u029c\u0292\3\2\2\2\u029c\u0293\3\2"+
"\2\2\u029c\u0294\3\2\2\2\u029c\u0295\3\2\2\2\u029c\u0296\3\2\2\2\u029c"+
"\u0297\3\2\2\2\u029c\u0298\3\2\2\2\u029c\u0299\3\2\2\2\u029c\u029a\3\2"+
"\2\2\u029c\u029b\3\2\2\2\u029d\u029f\3\2\2\2\u029e\u02a0\5\u00dco\2\u029f"+
"\u029e\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0\37\3\2\2\2\u02a1\u02a2\7\u0083"+
"\2\2\u02a2\u02a3\7\u00c7\2\2\u02a3!\3\2\2\2\u02a4\u02a5\7\65\2\2\u02a5"+
"\u02a7\5\u00b6\\\2\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02aa"+
"\3\2\2\2\u02a8\u02a9\7\64\2\2\u02a9\u02ab\5\u00b8]\2\u02aa\u02a8\3\2\2"+
"\2\u02aa\u02ab\3\2\2\2\u02ab\u02ac\3\2\2\2\u02ac\u02ad\7\32\2\2\u02ad"+
"\u02b0\5\u00ceh\2\u02ae\u02af\7 \2\2\u02af\u02b1\5\u00c0a\2\u02b0\u02ae"+
"\3\2\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b3\3\2\2\2\u02b2\u02b4\5\u010e\u0088"+
"\2\u02b3\u02b2\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b7\3\2\2\2\u02b5\u02b6"+
"\7\17\2\2\u02b6\u02b8\5\u00ccg\2\u02b7\u02b5\3\2\2\2\u02b7\u02b8\3\2\2"+
"\2\u02b8\u02bc\3\2\2\2\u02b9\u02ba\7*\2\2\u02ba\u02bb\7)\2\2\u02bb\u02bd"+
"\5\u00ecw\2\u02bc\u02b9\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02c0\3\2\2"+
"\2\u02be\u02bf\7+\2\2\u02bf\u02c1\5\u00fc\177\2\u02c0\u02be\3\2\2\2\u02c0"+
"\u02c1\3\2\2\2\u02c1\u02c4\3\2\2\2\u02c2\u02c3\7\60\2\2\u02c3\u02c5\5"+
"\u00fe\u0080\2\u02c4\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5\u02c9\3\2"+
"\2\2\u02c6\u02c7\7\67\2\2\u02c7\u02c8\7)\2\2\u02c8\u02ca\5\u00f8}\2\u02c9"+
"\u02c6\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca\u02cd\3\2\2\2\u02cb\u02cc\7p"+
"\2\2\u02cc\u02ce\5\u0104\u0083\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2\2"+
"\2\u02ce#\3\2\2\2\u02cf\u02d0\7\'\2\2\u02d0\u02e0\5&\24\2\u02d1\u02e1"+
"\5F$\2\u02d2\u02db\5<\37\2\u02d3\u02d5\5@!\2\u02d4\u02d3\3\2\2\2\u02d5"+
"\u02d6\3\2\2\2\u02d6\u02d4\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d9\3\2"+
"\2\2\u02d8\u02da\5D#\2\u02d9\u02d8\3\2\2\2\u02d9\u02da\3\2\2\2\u02da\u02dc"+
"\3\2\2\2\u02db\u02d4\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02e1\3\2\2\2\u02dd"+
"\u02e1\5H%\2\u02de\u02e1\5> \2\u02df\u02e1\5,\27\2\u02e0\u02d1\3\2\2\2"+
"\u02e0\u02d2\3\2\2\2\u02e0\u02dd\3\2\2\2\u02e0\u02de\3\2\2\2\u02e0\u02df"+
"\3\2\2\2\u02e1%\3\2\2\2\u02e2\u02e5\5\u0188\u00c5\2\u02e3\u02e5\5\u00de"+
"p\2\u02e4\u02e2\3\2\2\2\u02e4\u02e3\3\2\2\2\u02e5\u02e9\3\2\2\2\u02e6"+
"\u02e7\7\20\2\2\u02e7\u02ea\5\u01dc\u00ef\2\u02e8\u02ea\5\u01dc\u00ef"+
"\2\u02e9\u02e6\3\2\2\2\u02e9\u02e8\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\'"+
"\3\2\2\2\u02eb\u02ec\7r\2\2\u02ec\u02ed\7;\2\2\u02ed\u02ee\5*\26\2\u02ee"+
")\3\2\2\2\u02ef\u02f3\5\u01a4\u00d3\2\u02f0\u02f1\7\20\2\2\u02f1\u02f4"+
"\5\u01dc\u00ef\2\u02f2\u02f4\5\u01dc\u00ef\2\u02f3\u02f0\3\2\2\2\u02f3"+
"\u02f2\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u02f6\7R"+
"\2\2\u02f6\u02f9\5J&\2\u02f7\u02f8\7\17\2\2\u02f8\u02fa\5\u00ccg\2\u02f9"+
"\u02f7\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa+\3\2\2\2\u02fb\u02fd\7}\2\2\u02fc"+
"\u02fe\7\65\2\2\u02fd\u02fc\3\2\2\2\u02fd\u02fe\3\2\2\2\u02fe\u02ff\3"+
"\2\2\2\u02ff\u0303\7\u00c7\2\2\u0300\u0301\7\20\2\2\u0301\u0304\5\u01dc"+
"\u00ef\2\u0302\u0304\5\u01dc\u00ef\2\u0303\u0300\3\2\2\2\u0303\u0302\3"+
"\2\2\2\u0303\u0304\3\2\2\2\u0304\u030f\3\2\2\2\u0305\u0310\5\64\33\2\u0306"+
"\u0307\7\17\2\2\u0307\u0309\5\u00ccg\2\u0308\u0306\3\2\2\2\u0308\u0309"+
"\3\2\2\2\u0309\u030b\3\2\2\2\u030a\u030c\5.\30\2\u030b\u030a\3\2\2\2\u030c"+
"\u030d\3\2\2\2\u030d\u030b\3\2\2\2\u030d\u030e\3\2\2\2\u030e\u0310\3\2"+
"\2\2\u030f\u0305\3\2\2\2\u030f\u0308\3\2\2\2\u0310-\3\2\2\2\u0311\u0314"+
"\5\60\31\2\u0312\u0314\5\66\34\2\u0313\u0311\3\2\2\2\u0313\u0312\3\2\2"+
"\2\u0314/\3\2\2\2\u0315\u0316\7\35\2\2\u0316\u0319\7~\2\2\u0317\u0318"+
"\7\13\2\2\u0318\u031a\5\u0130\u0099\2\u0319\u0317\3\2\2\2\u0319\u031a"+
"\3\2\2\2\u031a\u031c\3\2\2\2\u031b\u031d\5\62\32\2\u031c\u031b\3\2\2\2"+
"\u031d\u031e\3\2\2\2\u031e\u031c\3\2\2\2\u031e\u031f\3\2\2\2\u031f\61"+
"\3\2\2\2\u0320\u032f\7\36\2\2\u0321\u0322\7r\2\2\u0322\u0323\7R\2\2\u0323"+
"\u0324\5J&\2\u0324\u0327\3\2\2\2\u0325\u0326\7\17\2\2\u0326\u0328\5\u00cc"+
"g\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0330\3\2\2\2\u0329"+
"\u032c\7P\2\2\u032a\u032b\7\17\2\2\u032b\u032d\5\u00ccg\2\u032c\u032a"+
"\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u0330\3\2\2\2\u032e\u0330\5:\36\2\u032f"+
"\u0321\3\2\2\2\u032f\u0329\3\2\2\2\u032f\u032e\3\2\2\2\u0330\63\3\2\2"+
"\2\u0331\u0336\7\64\2\2\u0332\u0333\7\u0093\2\2\u0333\u0334\5\u00bc_\2"+
"\u0334\u0335\7\u0094\2\2\u0335\u0337\3\2\2\2\u0336\u0332\3\2\2\2\u0336"+
"\u0337\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u0339\7\32\2\2\u0339\u033a\5"+
"\u00d0i\2\u033a\65\3\2\2\2\u033b\u033c\7\35\2\2\u033c\u033d\7\f\2\2\u033d"+
"\u0340\7~\2\2\u033e\u033f\7\13\2\2\u033f\u0341\5\u0130\u0099\2\u0340\u033e"+
"\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0343\3\2\2\2\u0342\u0344\58\35\2\u0343"+
"\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0343\3\2\2\2\u0345\u0346\3\2"+
"\2\2\u0346\67\3\2\2\2\u0347\u0348\7\36\2\2\u0348\u0349\5:\36\2\u03499"+
"\3\2\2\2\u034a\u034d\7\64\2\2\u034b\u034c\7\65\2\2\u034c\u034e\5\u01a4"+
"\u00d3\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u0353\3\2\2\2\u034f"+
"\u0350\7\u0093\2\2\u0350\u0351\5\u00bc_\2\u0351\u0352\7\u0094\2\2\u0352"+
"\u0354\3\2\2\2\u0353\u034f\3\2\2\2\u0353\u0354\3\2\2\2\u0354\u0356\3\2"+
"\2\2\u0355\u0357\5\u00ba^\2\u0356\u0355\3\2\2\2\u0356\u0357\3\2\2\2\u0357"+
"\u0358\3\2\2\2\u0358\u0359\7\32\2\2\u0359\u035c\5\u00d0i\2\u035a\u035b"+
"\7\17\2\2\u035b\u035d\5\u00ccg\2\u035c\u035a\3\2\2\2\u035c\u035d\3\2\2"+
"\2\u035d;\3\2\2\2\u035e\u035f\7\64\2\2\u035f\u0361\5\u00b8]\2\u0360\u035e"+
"\3\2\2\2\u0360\u0361\3\2\2\2\u0361\u0362\3\2\2\2\u0362\u0367\7\32\2\2"+
"\u0363\u0365\7\13\2\2\u0364\u0363\3\2\2\2\u0364\u0365\3\2\2\2\u0365\u0366"+
"\3\2\2\2\u0366\u0368\7P\2\2\u0367\u0364\3\2\2\2\u0367\u0368\3\2\2\2\u0368"+
"\u036a\3\2\2\2\u0369\u036b\7,\2\2\u036a\u0369\3\2\2\2\u036a\u036b\3\2"+
"\2\2\u036b\u036c\3\2\2\2\u036c\u036e\5\u00d0i\2\u036d\u036f\5N(\2\u036e"+
"\u036d\3\2\2\2\u036e\u036f\3\2\2\2\u036f\u0372\3\2\2\2\u0370\u0371\7\17"+
"\2\2\u0371\u0373\5\u00ccg\2\u0372\u0370\3\2\2\2\u0372\u0373\3\2\2\2\u0373"+
"\u0377\3\2\2\2\u0374\u0375\7*\2\2\u0375\u0376\7)\2\2\u0376\u0378\5\u00ec"+
"w\2\u0377\u0374\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u037b\3\2\2\2\u0379"+
"\u037a\7+\2\2\u037a\u037c\5\u00fc\177\2\u037b\u0379\3\2\2\2\u037b\u037c"+
"\3\2\2\2\u037c\u0380\3\2\2\2\u037d\u037e\7\67\2\2\u037e\u037f\7)\2\2\u037f"+
"\u0381\5\u00f8}\2\u0380\u037d\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0384"+
"\3\2\2\2\u0382\u0383\7p\2\2\u0383\u0385\5\u0104\u0083\2\u0384\u0382\3"+
"\2\2\2\u0384\u0385\3\2\2\2\u0385=\3\2\2\2\u0386\u0387\7r\2\2\u0387\u038b"+
"\7\u00c7\2\2\u0388\u0389\7\20\2\2\u0389\u038c\5\u01dc\u00ef\2\u038a\u038c"+
"\5\u01dc\u00ef\2\u038b\u0388\3\2\2\2\u038b\u038a\3\2\2\2\u038b\u038c\3"+
"\2\2\2\u038c\u038d\3\2\2\2\u038d\u038e\7R\2\2\u038e\u0391\5J&\2\u038f"+
"\u0390\7\17\2\2\u0390\u0392\5\u00ccg\2\u0391\u038f\3\2\2\2\u0391\u0392"+
"\3\2\2\2\u0392?\3\2\2\2\u0393\u0394\7\64\2\2\u0394\u0395\5\u00b8]\2\u0395"+
"\u0396\7\32\2\2\u0396\u0398\5\u00d0i\2\u0397\u0399\5B\"\2\u0398\u0397"+
"\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u039c\3\2\2\2\u039a\u039b\7\17\2\2"+
"\u039b\u039d\5\u00ccg\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2\2\2\u039d"+
"A\3\2\2\2\u039e\u039f\7 \2\2\u039f\u03a3\5\u018a\u00c6\2\u03a0\u03a1\7"+
"\20\2\2\u03a1\u03a4\5\u01dc\u00ef\2\u03a2\u03a4\5\u01dc\u00ef\2\u03a3"+
"\u03a0\3\2\2\2\u03a3\u03a2\3\2\2\2\u03a3\u03a4\3\2\2\2\u03a4C\3\2\2\2"+
"\u03a5\u03a8\7\60\2\2\u03a6\u03a9\7\62\2\2\u03a7\u03a9\7-\2\2\u03a8\u03a6"+
"\3\2\2\2\u03a8\u03a7\3\2\2\2\u03a9E\3\2\2\2\u03aa\u03ab\7P\2\2\u03ab\u03ae"+
"\5N(\2\u03ac\u03ad\7\17\2\2\u03ad\u03af\5\u00ccg\2\u03ae\u03ac\3\2\2\2"+
"\u03ae\u03af\3\2\2\2\u03afG\3\2\2\2\u03b0\u03b1\7R\2\2\u03b1\u03b2\5J"+
"&\2\u03b2I\3\2\2\2\u03b3\u03b8\5L\'\2\u03b4\u03b5\7\u009a\2\2\u03b5\u03b7"+
"\5L\'\2\u03b6\u03b4\3\2\2\2\u03b7\u03ba\3\2\2\2\u03b8\u03b6\3\2\2\2\u03b8"+
"\u03b9\3\2\2\2\u03b9K\3\2\2\2\u03ba\u03b8\3\2\2\2\u03bb\u03bc\5\u01cc"+
"\u00e7\2\u03bc\u03bd\7\u0090\2\2\u03bd\u03be\5\u0130\u0099\2\u03be\u03c1"+
"\3\2\2\2\u03bf\u03c1\5\u0130\u0099\2\u03c0\u03bb\3\2\2\2\u03c0\u03bf\3"+
"\2\2\2\u03c1M\3\2\2\2\u03c2\u03c3\7 \2\2\u03c3\u03c7\7\u00c7\2\2\u03c4"+
"\u03c5\7\20\2\2\u03c5\u03c8\5\u01dc\u00ef\2\u03c6\u03c8\5\u01dc\u00ef"+
"\2\u03c7\u03c4\3\2\2\2\u03c7\u03c6\3\2\2\2\u03c7\u03c8\3\2\2\2\u03c8O"+
"\3\2\2\2\u03c9\u03ca\7\3\2\2\u03ca\u03cb\7\4\2\2\u03cb\u03cd\7\u00c7\2"+
"\2\u03cc\u03ce\5\u00e4s\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce"+
"\u03d1\3\2\2\2\u03cf\u03d2\7?\2\2\u03d0\u03d2\7@\2\2\u03d1\u03cf\3\2\2"+
"\2\u03d1\u03d0\3\2\2\2\u03d1\u03d2\3\2\2\2\u03d2\u03d4\3\2\2\2\u03d3\u03d5"+
"\7\20\2\2\u03d4\u03d3\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5\u03db\3\2\2\2"+
"\u03d6\u03dc\5R*\2\u03d7\u03d8\7\u0093\2\2\u03d8\u03d9\5b\62\2\u03d9\u03da"+
"\7\u0094\2\2\u03da\u03dc\3\2\2\2\u03db\u03d6\3\2\2\2\u03db\u03d7\3\2\2"+
"\2\u03dc\u03e2\3\2\2\2\u03dd\u03e0\7\64\2\2\u03de\u03df\7\17\2\2\u03df"+
"\u03e1\5\u0130\u0099\2\u03e0\u03de\3\2\2\2\u03e0\u03e1\3\2\2\2\u03e1\u03e3"+
"\3\2\2\2\u03e2\u03dd\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3Q\3\2\2\2\u03e4"+
"\u03e5\7\32\2\2\u03e5\u03e6\5f\64\2\u03e6\u03e7\7 \2\2\u03e7\u03e9\3\2"+
"\2\2\u03e8\u03e4\3\2\2\2\u03e8\u03e9\3\2\2\2\u03e9\u03ea\3\2\2\2\u03ea"+
"\u03eb\5\u01a4\u00d3\2\u03ebS\3\2\2\2\u03ec\u03ee\7\3\2\2\u03ed\u03ef"+
"\7\u00c7\2\2\u03ee\u03ed\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\3\2\2"+
"\2\u03f0\u03f1\7W\2\2\u03f1\u03f2\7\u00c7\2\2\u03f2\u03f3\7\'\2\2\u03f3"+
"\u03f4\7\u00c7\2\2\u03f4\u03f5\7\u0093\2\2\u03f5\u03f6\5V,\2\u03f6\u03f7"+
"\7\u0094\2\2\u03f7U\3\2\2\2\u03f8\u03fd\5X-\2\u03f9\u03fa\7\u009a\2\2"+
"\u03fa\u03fc\5X-\2\u03fb\u03f9\3\2\2\2\u03fc\u03ff\3\2\2\2\u03fd\u03fb"+
"\3\2\2\2\u03fd\u03fe\3\2\2\2\u03feW\3\2\2\2\u03ff\u03fd\3\2\2\2\u0400"+
"\u0407\5\u0130\u0099\2\u0401\u0403\7\u0093\2\2\u0402\u0404\5\u01b2\u00da"+
"\2\u0403\u0402\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0407"+
"\7\u0094\2\2\u0406\u0400\3\2\2\2\u0406\u0401\3\2\2\2\u0407\u0410\3\2\2"+
"\2\u0408\u040e\7\u00c7\2\2\u0409\u040b\7\u0093\2\2\u040a\u040c\5\u01b2"+
"\u00da\2\u040b\u040a\3\2\2\2\u040b\u040c\3\2\2\2\u040c\u040d\3\2\2\2\u040d"+
"\u040f\7\u0094\2\2\u040e\u0409\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0411"+
"\3\2\2\2\u0410\u0408\3\2\2\2\u0410\u0411\3\2\2\2\u0411Y\3\2\2\2\u0412"+
"\u0414\7\3\2\2\u0413\u0415\7\u00c7\2\2\u0414\u0413\3\2\2\2\u0414\u0415"+
"\3\2\2\2\u0415\u0416\3\2\2\2\u0416\u0417\7S\2\2\u0417\u0418\5\u019e\u00d0"+
"\2\u0418\u041b\7\u00c7\2\2\u0419\u041a\7\u0090\2\2\u041a\u041c\5\u0130"+
"\u0099\2\u041b\u0419\3\2\2\2\u041b\u041c\3\2\2\2\u041c[\3\2\2\2\u041d"+
"\u041e\7\3\2\2\u041e\u041f\7T\2\2\u041f\u0421\7\u00c7\2\2\u0420\u0422"+
"\7\20\2\2\u0421\u0420\3\2\2\2\u0421\u0422\3\2\2\2\u0422\u0423\3\2\2\2"+
"\u0423\u0424\7\u0093\2\2\u0424\u0425\5^\60\2\u0425\u0426\7\u0094\2\2\u0426"+
"]\3\2\2\2\u0427\u042c\5`\61\2\u0428\u0429\7\u009a\2\2\u0429\u042b\5`\61"+
"\2\u042a\u0428\3\2\2\2\u042b\u042e\3\2\2\2\u042c\u042a\3\2\2\2\u042c\u042d"+
"\3\2\2\2\u042d_\3\2\2\2\u042e\u042c\3\2\2\2\u042f\u0433\7\u00c7\2\2\u0430"+
"\u0434\5\u019e\u00d0\2\u0431\u0434\5\u015c\u00af\2\u0432\u0434\5\u01cc"+
"\u00e7\2\u0433\u0430\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0432\3\2\2\2\u0434"+
"\u0436\3\2\2\2\u0435\u0437\7\u00c7\2\2\u0436\u0435\3\2\2\2\u0436\u0437"+
"\3\2\2\2\u0437\u0439\3\2\2\2\u0438\u043a\7\u00c7\2\2\u0439\u0438\3\2\2"+
"\2\u0439\u043a\3\2\2\2\u043a\u043f\3\2\2\2\u043b\u043e\5\u0196\u00cc\2"+
"\u043c\u043e\5\24\13\2\u043d\u043b\3\2\2\2\u043d\u043c\3\2\2\2\u043e\u0441"+
"\3\2\2\2\u043f\u043d\3\2\2\2\u043f\u0440\3\2\2\2\u0440a\3\2\2\2\u0441"+
"\u043f\3\2\2\2\u0442\u0447\5d\63\2\u0443\u0444\7\u009a\2\2\u0444\u0446"+
"\5d\63\2\u0445\u0443\3\2\2\2\u0446\u0449\3\2\2\2\u0447\u0445\3\2\2\2\u0447"+
"\u0448\3\2\2\2\u0448c\3\2\2\2\u0449\u0447\3\2\2\2\u044a\u044d\5\u01a4"+
"\u00d3\2\u044b\u044e\7o\2\2\u044c\u044e\5\u019e\u00d0\2\u044d\u044b\3"+
"\2\2\2\u044d\u044c\3\2\2\2\u044ee\3\2\2\2\u044f\u0454\5h\65\2\u0450\u0451"+
"\7\u009a\2\2\u0451\u0453\5h\65\2\u0452\u0450\3\2\2\2\u0453\u0456\3\2\2"+
"\2\u0454\u0452\3\2\2\2\u0454\u0455\3\2\2\2\u0455g\3\2\2\2\u0456\u0454"+
"\3\2\2\2\u0457\u0462\7\u00a7\2\2\u0458\u045b\5\u01cc\u00e7\2\u0459\u045a"+
"\7\20\2\2\u045a\u045c\7\u00c7\2\2\u045b\u0459\3\2\2\2\u045b\u045c\3\2"+
"\2\2\u045c\u0462\3\2\2\2\u045d\u045e\5\u01fe\u0100\2\u045e\u045f\7\20"+
"\2\2\u045f\u0460\7\u00c7\2\2\u0460\u0462\3\2\2\2\u0461\u0457\3\2\2\2\u0461"+
"\u0458\3\2\2\2\u0461\u045d\3\2\2\2\u0462i\3\2\2\2\u0463\u0465\7\3\2\2"+
"\u0464\u0466\7\u00c7\2\2\u0465\u0464\3\2\2\2\u0465\u0466\3\2\2\2\u0466"+
"\u0467\3\2\2\2\u0467\u0468\5l\67\2\u0468k\3\2\2\2\u0469\u046a\7=\2\2\u046a"+
"\u046c\7\u00c7\2\2\u046b\u046d\7\20\2\2\u046c\u046b\3\2\2\2\u046c\u046d"+
"\3\2\2\2\u046d\u0474\3\2\2\2\u046e\u0475\5\u00b2Z\2\u046f\u0471\7\u0093"+
"\2\2\u0470\u0472\5b\62\2\u0471\u0470\3\2\2\2\u0471\u0472\3\2\2\2\u0472"+
"\u0473\3\2\2\2\u0473\u0475\7\u0094\2\2\u0474\u046e\3\2\2\2\u0474\u046f"+
"\3\2\2\2\u0475\u0479\3\2\2\2\u0476\u0478\5\u00b0Y\2\u0477\u0476\3\2\2"+
"\2\u0478\u047b\3\2\2\2\u0479\u0477\3\2\2\2\u0479\u047a\3\2\2\2\u047am"+
"\3\2\2\2\u047b\u0479\3\2\2\2\u047c\u047d\7P\2\2\u047d\u047e\7 \2\2\u047e"+
"\u0482\5\u01a4\u00d3\2\u047f\u0480\7\20\2\2\u0480\u0483\5\u01dc\u00ef"+
"\2\u0481\u0483\5\u01dc\u00ef\2\u0482\u047f\3\2\2\2\u0482\u0481\3\2\2\2"+
"\u0482\u0483\3\2\2\2\u0483\u0486\3\2\2\2\u0484\u0485\7\17\2\2\u0485\u0487"+
"\5\u00ccg\2\u0486\u0484\3\2\2\2\u0486\u0487\3\2\2\2\u0487o\3\2\2\2\u0488"+
"\u0489\7r\2\2\u0489\u048a\5*\26\2\u048aq\3\2\2\2\u048b\u048c\7\64\2\2"+
"\u048c\u048d\5\u00b8]\2\u048d\u048e\7\66\2\2\u048e\u0493\5t;\2\u048f\u0490"+
"\7\u009a\2\2\u0490\u0492\5t;\2\u0491\u048f\3\2\2\2\u0492\u0495\3\2\2\2"+
"\u0493\u0491\3\2\2\2\u0493\u0494\3\2\2\2\u0494s\3\2\2\2\u0495\u0493\3"+
"\2\2\2\u0496\u0497\7\u0093\2\2\u0497\u0498\5\u01b2\u00da\2\u0498\u0499"+
"\7\u0094\2\2\u0499u\3\2\2\2\u049a\u049b\7\3\2\2\u049b\u049c\7\u0086\2"+
"\2\u049c\u049e\7\u00c7\2\2\u049d\u049f\7\20\2\2\u049e\u049d\3\2\2\2\u049e"+
"\u049f\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\5x=\2\u04a1w\3\2\2\2\u04a2"+
"\u04a6\5z>\2\u04a3\u04a5\5z>\2\u04a4\u04a3\3\2\2\2\u04a5\u04a8\3\2\2\2"+
"\u04a6\u04a4\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7y\3\2\2\2\u04a8\u04a6\3"+
"\2\2\2\u04a9\u04ab\5\24\13\2\u04aa\u04a9\3\2\2\2\u04ab\u04ae\3\2\2\2\u04ac"+
"\u04aa\3\2\2\2\u04ac\u04ad\3\2\2\2\u04ad\u04b1\3\2\2\2\u04ae\u04ac\3\2"+
"\2\2\u04af\u04b2\7\u00c7\2\2\u04b0\u04b2\7\32\2\2\u04b1\u04af\3\2\2\2"+
"\u04b1\u04b0\3\2\2\2\u04b2\u04b4\3\2\2\2\u04b3\u04b5\5|?\2\u04b4\u04b3"+
"\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b7\3\2\2\2\u04b6\u04b8\5\u0086D"+
"\2\u04b7\u04b6\3\2\2\2\u04b7\u04b8\3\2\2\2\u04b8\u04b9\3\2\2\2\u04b9\u04bb"+
"\7\u0097\2\2\u04ba\u04bc\5\u0090I\2\u04bb\u04ba\3\2\2\2\u04bb\u04bc\3"+
"\2\2\2\u04bc\u04be\3\2\2\2\u04bd\u04bf\7\u009a\2\2\u04be\u04bd\3\2\2\2"+
"\u04be\u04bf\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c5\7\u0098\2\2\u04c1"+
"\u04c2\5j\66\2\u04c2\u04c3\7\u009a\2\2\u04c3\u04c5\3\2\2\2\u04c4\u04ac"+
"\3\2\2\2\u04c4\u04c1\3\2\2\2\u04c5{\3\2\2\2\u04c6\u04c7\7\u0093\2\2\u04c7"+
"\u04c8\5~@\2\u04c8\u04c9\7\u0094\2\2\u04c9}\3\2\2\2\u04ca\u04cf\5\u0080"+
"A\2\u04cb\u04cc\7\u009a\2\2\u04cc\u04ce\5\u0080A\2\u04cd\u04cb\3\2\2\2"+
"\u04ce\u04d1\3\2\2\2\u04cf\u04cd\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\177"+
"\3\2\2\2\u04d1\u04cf\3\2\2\2\u04d2\u04d5\5\u01a4\u00d3\2\u04d3\u04d5\5"+
"\u0082B\2\u04d4\u04d2\3\2\2\2\u04d4\u04d3\3\2\2\2\u04d5\u04d7\3\2\2\2"+
"\u04d6\u04d8\5\u0084C\2\u04d7\u04d6\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8"+
"\u0081\3\2\2\2\u04d9\u04da\7\u0093\2\2\u04da\u04db\5\u01a4\u00d3\2\u04db"+
"\u04dc\7\u009a\2\2\u04dc\u04dd\5\u01a4\u00d3\2\u04dd\u04de\3\2\2\2\u04de"+
"\u04df\7\u0094\2\2\u04df\u0083\3\2\2\2\u04e0\u04e1\7\20\2\2\u04e1\u04e2"+
"\7\u00c7\2\2\u04e2\u0085\3\2\2\2\u04e3\u04e4\7\u008e\2\2\u04e4\u04e9\5"+
"\u0088E\2\u04e5\u04e6\7\u009a\2\2\u04e6\u04e8\5\u0088E\2\u04e7\u04e5\3"+
"\2\2\2\u04e8\u04eb\3\2\2\2\u04e9\u04e7\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea"+
"\u0087\3\2\2\2\u04eb\u04e9\3\2\2\2\u04ec\u04ee\5\u01a4\u00d3\2\u04ed\u04ef"+
"\5\u008aF\2\u04ee\u04ed\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u0089\3\2\2"+
"\2\u04f0\u04f1\7\u00ae\2\2\u04f1\u04f6\5\u008cG\2\u04f2\u04f3\7\u009a"+
"\2\2\u04f3\u04f5\5\u008cG\2\u04f4\u04f2\3\2\2\2\u04f5\u04f8\3\2\2\2\u04f6"+
"\u04f4\3\2\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04f9\3\2\2\2\u04f8\u04f6\3\2"+
"\2\2\u04f9\u04fa\7\u00ac\2\2\u04fa\u008b\3\2\2\2\u04fb\u04fe\5\u008eH"+
"\2\u04fc\u04fe\7\u0092\2\2\u04fd\u04fb\3\2\2\2\u04fd\u04fc\3\2\2\2\u04fe"+
"\u008d\3\2\2\2\u04ff\u0501\5\u01a4\u00d3\2\u0500\u0502\5\u008aF\2\u0501"+
"\u0500\3\2\2\2\u0501\u0502\3\2\2\2\u0502\u008f\3\2\2\2\u0503\u0508\5\u0092"+
"J\2\u0504\u0505\7\u009a\2\2\u0505\u0507\5\u0092J\2\u0506\u0504\3\2\2\2"+
"\u0507\u050a\3\2\2\2\u0508\u0506\3\2\2\2\u0508\u0509\3\2\2\2\u0509\u0091"+
"\3\2\2\2\u050a\u0508\3\2\2\2\u050b\u050c\7\32\2\2\u050c\u050d\t\3\2\2"+
"\u050d\u050e\7\u0093\2\2\u050e\u050f\5\"\22\2\u050f\u0510\7\u0094\2\2"+
"\u0510\u0519\3\2\2\2\u0511\u0512\7\u00c7\2\2\u0512\u0516\t\3\2\2\u0513"+
"\u0517\5\u0130\u0099\2\u0514\u0517\5\u0206\u0104\2\u0515\u0517\5\u0208"+
"\u0105\2\u0516\u0513\3\2\2\2\u0516\u0514\3\2\2\2\u0516\u0515\3\2\2\2\u0517"+
"\u0519\3\2\2\2\u0518\u050b\3\2\2\2\u0518\u0511\3\2\2\2\u0519\u0093\3\2"+
"\2\2\u051a\u051b\7\3\2\2\u051b\u051c\7\u0083\2\2\u051c\u051e\7\u00c7\2"+
"\2\u051d\u051f\7\20\2\2\u051e\u051d\3\2\2\2\u051e\u051f\3\2\2\2\u051f"+
"\u0520\3\2\2\2\u0520\u0521\5\u009aN\2\u0521\u0095\3\2\2\2\u0522\u0523"+
"\7\3\2\2\u0523\u0524\5\n\6\2\u0524\u0097\3\2\2\2\u0525\u0526\7\3\2\2\u0526"+
"\u0527\5\b\5\2\u0527\u0099\3\2\2\2\u0528\u0534\5\u009eP\2\u0529\u052a"+
"\5\u009cO\2\u052a\u052b\7\u009a\2\2\u052b\u0530\5\u009cO\2\u052c\u052d"+
"\7\u009a\2\2\u052d\u052f\5\u009cO\2\u052e\u052c\3\2\2\2\u052f\u0532\3"+
"\2\2\2\u0530\u052e\3\2\2\2\u0530\u0531\3\2\2\2\u0531\u0534\3\2\2\2\u0532"+
"\u0530\3\2\2\2\u0533\u0528\3\2\2\2\u0533\u0529\3\2\2\2\u0534\u009b\3\2"+
"\2\2\u0535\u0536\7\u0083\2\2\u0536\u0538\7\u00c7\2\2\u0537\u0539\7\20"+
"\2\2\u0538\u0537\3\2\2\2\u0538\u0539\3\2\2\2\u0539\u053a\3\2\2\2\u053a"+
"\u053b\5\u009eP\2\u053b\u009d\3\2\2\2\u053c\u0540\7\u0082\2\2\u053d\u053e"+
"\7\u00be\2\2\u053e\u0541\7\u00c7\2\2\u053f\u0541\5\u00a2R\2\u0540\u053d"+
"\3\2\2\2\u0540\u053f\3\2\2\2\u0541\u0544\3\2\2\2\u0542\u0543\7\37\2\2"+
"\u0543\u0545\5\u00a2R\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545"+
"\u0589\3\2\2\2\u0546\u0548\7\u0084\2\2\u0547\u0549\7)\2\2\u0548\u0547"+
"\3\2\2\2\u0548\u0549\3\2\2\2\u0549\u054b\3\2\2\2\u054a\u054c\5\u00a0Q"+
"\2\u054b\u054a\3\2\2\2\u054b\u054c\3\2\2\2\u054c\u0550\3\2\2\2\u054d\u054e"+
"\7\u00be\2\2\u054e\u054f\7\u00c7\2\2\u054f\u0551\7\13\2\2\u0550\u054d"+
"\3\2\2\2\u0550\u0551\3\2\2\2\u0551\u0552\3\2\2\2\u0552\u0558\5\u00a2R"+
"\2\u0553\u0555\7\u0085\2\2\u0554\u0556\7)\2\2\u0555\u0554\3\2\2\2\u0555"+
"\u0556\3\2\2\2\u0556\u0557\3\2\2\2\u0557\u0559\5\u00a2R\2\u0558\u0553"+
"\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u0589\3\2\2\2\u055a\u055c\7w\2\2\u055b"+
"\u055d\7)\2\2\u055c\u055b\3\2\2\2\u055c\u055d\3\2\2\2\u055d\u055e\3\2"+
"\2\2\u055e\u0563\5\u00a6T\2\u055f\u0560\7\u009a\2\2\u0560\u0562\5\u00a6"+
"T\2\u0561\u055f\3\2\2\2\u0562\u0565\3\2\2\2\u0563\u0561\3\2\2\2\u0563"+
"\u0564\3\2\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0566\u0568\5\u00ac"+
"W\2\u0567\u0566\3\2\2\2\u0567\u0568\3\2\2\2\u0568\u056a\3\2\2\2\u0569"+
"\u056b\5\u00aeX\2\u056a\u0569\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u0589"+
"\3\2\2\2\u056c\u0571\5\u00aaV\2\u056d\u056e\7\u009a\2\2\u056e\u0570\5"+
"\u00aaV\2\u056f\u056d\3\2\2\2\u0570\u0573\3\2\2\2\u0571\u056f\3\2\2\2"+
"\u0571\u0572\3\2\2\2\u0572\u0574\3\2\2\2\u0573\u0571\3\2\2\2\u0574\u0575"+
"\7 \2\2\u0575\u0576\5\u0188\u00c5\2\u0576\u0589\3\2\2\2\u0577\u0579\7"+
"\25\2\2\u0578\u057a\7)\2\2\u0579\u0578\3\2\2\2\u0579\u057a\3\2\2\2\u057a"+
"\u057b\3\2\2\2\u057b\u0580\5\u00a8U\2\u057c\u057d\7\u009a\2\2\u057d\u057f"+
"\5\u00a8U\2\u057e\u057c\3\2\2\2\u057f\u0582\3\2\2\2\u0580\u057e\3\2\2"+
"\2\u0580\u0581\3\2\2\2\u0581\u0583\3\2\2\2\u0582\u0580\3\2\2\2\u0583\u0584"+
"\7\u00c7\2\2\u0584\u0586\5\u01f8\u00fd\2\u0585\u0587\7\u00c7\2\2\u0586"+
"\u0585\3\2\2\2\u0586\u0587\3\2\2\2\u0587\u0589\3\2\2\2\u0588\u053c\3\2"+
"\2\2\u0588\u0546\3\2\2\2\u0588\u055a\3\2\2\2\u0588\u056c\3\2\2\2\u0588"+
"\u0577\3\2\2\2\u0589\u009f\3\2\2\2\u058a\u058b\7,\2\2\u058b\u058d\7\u0093"+
"\2\2\u058c\u058e\5\u01b2\u00da\2\u058d\u058c\3\2\2\2\u058d\u058e\3\2\2"+
"\2\u058e\u058f\3\2\2\2\u058f\u0590\7\u0094\2\2\u0590\u00a1\3\2\2\2\u0591"+
"\u05a1\5\u00a4S\2\u0592\u0595\5\u00dep\2\u0593\u0594\7\u00be\2\2\u0594"+
"\u0596\7\u00c7\2\2\u0595\u0593\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u059b"+
"\3\2\2\2\u0597\u0599\7\20\2\2\u0598\u0597\3\2\2\2\u0598\u0599\3\2\2\2"+
"\u0599\u059a\3\2\2\2\u059a\u059c\5\u01de\u00f0\2\u059b\u0598\3\2\2\2\u059b"+
"\u059c\3\2\2\2\u059c\u05a1\3\2\2\2\u059d\u05a1\5\u0106\u0084\2\u059e\u059f"+
"\7y\2\2\u059f\u05a1\5\u01e4\u00f3\2\u05a0\u0591\3\2\2\2\u05a0\u0592\3"+
"\2\2\2\u05a0\u059d\3\2\2\2\u05a0\u059e\3\2\2\2\u05a1\u00a3\3\2\2\2\u05a2"+
"\u05a7\5\u0188\u00c5\2\u05a3\u05a5\7\20\2\2\u05a4\u05a3\3\2\2\2\u05a4"+
"\u05a5\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u05a8\7\u00c7\2\2\u05a7\u05a4"+
"\3\2\2\2\u05a7\u05a8\3\2\2\2\u05a8\u00a5\3\2\2\2\u05a9\u05ae\5\u01cc\u00e7"+
"\2\u05aa\u05ab\t\4\2\2\u05ab\u05ad\5\u01cc\u00e7\2\u05ac\u05aa\3\2\2\2"+
"\u05ad\u05b0\3\2\2\2\u05ae\u05ac\3\2\2\2\u05ae\u05af\3\2\2\2\u05af\u05b1"+
"\3\2\2\2\u05b0\u05ae\3\2\2\2\u05b1\u05b2\7 \2\2\u05b2\u05b7\5\u0188\u00c5"+
"\2\u05b3\u05b5\7\20\2\2\u05b4\u05b3\3\2\2\2\u05b4\u05b5\3\2\2\2\u05b5"+
"\u05b6\3\2\2\2\u05b6\u05b8\5\u01de\u00f0\2\u05b7\u05b4\3\2\2\2\u05b7\u05b8"+
"\3\2\2\2\u05b8\u00a7\3\2\2\2\u05b9\u05ba\5\u01cc\u00e7\2\u05ba\u05bb\7"+
" \2\2\u05bb\u05bc\5\u0188\u00c5\2\u05bc\u00a9\3\2\2\2\u05bd\u05bf\7*\2"+
"\2\u05be\u05c0\7)\2\2\u05bf\u05be\3\2\2\2\u05bf\u05c0\3\2\2\2\u05c0\u05c1"+
"\3\2\2\2\u05c1\u05c2\5\u0130\u0099\2\u05c2\u05c3\7\20\2\2\u05c3\u05c4"+
"\7\u00c7\2\2\u05c4\u00ab\3\2\2\2\u05c5\u05c7\7\u0084\2\2\u05c6\u05c8\7"+
")\2\2\u05c7\u05c6\3\2\2\2\u05c7\u05c8\3\2\2\2\u05c8\u05c9\3\2\2\2\u05c9"+
"\u05ce\5\u00a4S\2\u05ca\u05cb\7\u009a\2\2\u05cb\u05cd\5\u00a4S\2\u05cc"+
"\u05ca\3\2\2\2\u05cd\u05d0\3\2\2\2\u05ce\u05cc\3\2\2\2\u05ce\u05cf\3\2"+
"\2\2\u05cf\u00ad\3\2\2\2\u05d0\u05ce\3\2\2\2\u05d1\u05d3\7\u0085\2\2\u05d2"+
"\u05d4\7)\2\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u05d5\3\2"+
"\2\2\u05d5\u05d6\5\u00a2R\2\u05d6\u00af\3\2\2\2\u05d7\u05d8\7\u00c7\2"+
"\2\u05d8\u05d9\5\u00bc_\2\u05d9\u00b1\3\2\2\2\u05da\u05df\5\u00b4[\2\u05db"+
"\u05dc\7\u009a\2\2\u05dc\u05de\5\u00b4[\2\u05dd\u05db\3\2\2\2\u05de\u05e1"+
"\3\2\2\2\u05df\u05dd\3\2\2\2\u05df\u05e0\3\2\2\2\u05e0\u00b3\3\2\2\2\u05e1"+
"\u05df\3\2\2\2\u05e2\u05e5\7\u00a7\2\2\u05e3\u05e5\5\u019e\u00d0\2\u05e4"+
"\u05e2\3\2\2\2\u05e4\u05e3\3\2\2\2\u05e5\u00b5\3\2\2\2\u05e6\u05e7\7T"+
"\2\2\u05e7\u05e8\7\u00c7\2\2\u05e8\u00b7\3\2\2\2\u05e9\u05ed\7;\2\2\u05ea"+
"\u05ed\7:\2\2\u05eb\u05ed\7<\2\2\u05ec\u05e9\3\2\2\2\u05ec\u05ea\3\2\2"+
"\2\u05ec\u05eb\3\2\2\2\u05ec\u05ed\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee\u05ef"+
"\7\65\2\2\u05ef\u05f5\5\u01a4\u00d3\2\u05f0\u05f2\7\u0093\2\2\u05f1\u05f3"+
"\5\u00bc_\2\u05f2\u05f1\3\2\2\2\u05f2\u05f3\3\2\2\2\u05f3\u05f4\3\2\2"+
"\2\u05f4\u05f6\7\u0094\2\2\u05f5\u05f0\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6"+
"\u05f8\3\2\2\2\u05f7\u05f9\5\u00ba^\2\u05f8\u05f7\3\2\2\2\u05f8\u05f9"+
"\3\2\2\2\u05f9\u00b9\3\2\2\2\u05fa\u05fb\7\u008c\2\2\u05fb\u05fc\7\u0093"+
"\2\2\u05fc\u05fd\5\u0130\u0099\2\u05fd\u05fe\7\u0094\2\2\u05fe\u00bb\3"+
"\2\2\2\u05ff\u0604\7\u00c7\2\2\u0600\u0601\7\u009a\2\2\u0601\u0603\7\u00c7"+
"\2\2\u0602\u0600\3\2\2\2\u0603\u0606\3\2\2\2\u0604\u0602\3\2\2\2\u0604"+
"\u0605\3\2\2\2\u0605\u00bd\3\2\2\2\u0606\u0604\3\2\2\2\u0607\u060c\5\u01de"+
"\u00f0\2\u0608\u0609\7\u009a\2\2\u0609\u060b\5\u01de\u00f0\2\u060a\u0608"+
"\3\2\2\2\u060b\u060e\3\2\2\2\u060c\u060a\3\2\2\2\u060c\u060d\3\2\2\2\u060d"+
"\u00bf\3\2\2\2\u060e\u060c\3\2\2\2\u060f\u0612\5\u00dan\2\u0610\u0613"+
"\5\u00c2b\2\u0611\u0613\5\u00c4c\2\u0612\u0610\3\2\2\2\u0612\u0611\3\2"+
"\2\2\u0613\u00c1\3\2\2\2\u0614\u0615\7\u009a\2\2\u0615\u0617\5\u00dan"+
"\2\u0616\u0614\3\2\2\2\u0617\u061a\3\2\2\2\u0618\u0616\3\2\2\2\u0618\u0619"+
"\3\2\2\2\u0619\u00c3\3\2\2\2\u061a\u0618\3\2\2\2\u061b\u061f\5\u00c6d"+
"\2\u061c\u061e\5\u00c6d\2\u061d\u061c\3\2\2\2\u061e\u0621\3\2\2\2\u061f"+
"\u061d\3\2\2\2\u061f\u0620\3\2\2\2\u0620\u00c5\3\2\2\2\u0621\u061f\3\2"+
"\2\2\u0622\u0626\7$\2\2\u0623\u0626\7%\2\2\u0624\u0626\7&\2\2\u0625\u0622"+
"\3\2\2\2\u0625\u0623\3\2\2\2\u0625\u0624\3\2\2\2\u0626\u0627\3\2\2\2\u0627"+
"\u0629\7!\2\2\u0628\u0625\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u062c\3\2"+
"\2\2\u062a\u062c\7\"\2\2\u062b\u0628\3\2\2\2\u062b\u062a\3\2\2\2\u062c"+
"\u062d\3\2\2\2\u062d\u062e\7#\2\2\u062e\u0630\5\u00dan\2\u062f\u0631\5"+
"\u00c8e\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u00c7\3\2\2\2"+
"\u0632\u0633\7\'\2\2\u0633\u0638\5\u00caf\2\u0634\u0635\7\13\2\2\u0635"+
"\u0637\5\u00caf\2\u0636\u0634\3\2\2\2\u0637\u063a\3\2\2\2\u0638\u0636"+
"\3\2\2\2\u0638\u0639\3\2\2\2\u0639\u00c9\3\2\2\2\u063a\u0638\3\2\2\2\u063b"+
"\u063c\5\u01cc\u00e7\2\u063c\u063d\7\u0090\2\2\u063d\u063e\5\u01cc\u00e7"+
"\2\u063e\u00cb\3\2\2\2\u063f\u0640\5\u0134\u009b\2\u0640\u00cd\3\2\2\2"+
"\u0641\u0645\7:\2\2\u0642\u0645\7;\2\2\u0643\u0645\7<\2\2\u0644\u0641"+
"\3\2\2\2\u0644\u0642\3\2\2\2\u0644\u0643\3\2\2\2\u0644\u0645\3\2\2\2\u0645"+
"\u0647\3\2\2\2\u0646\u0648\7,\2\2\u0647\u0646\3\2\2\2\u0647\u0648\3\2"+
"\2\2\u0648\u0649\3\2\2\2\u0649\u064a\5\u00d0i\2\u064a\u00cf\3\2\2\2\u064b"+
"\u0650\5\u00d2j\2\u064c\u064d\7\u009a\2\2\u064d\u064f\5\u00d2j\2\u064e"+
"\u064c\3\2\2\2\u064f\u0652\3\2\2\2\u0650\u064e\3\2\2\2\u0650\u0651\3\2"+
"\2\2\u0651\u00d1\3\2\2\2\u0652\u0650\3\2\2\2\u0653\u0657\7\u00a7\2\2\u0654"+
"\u0657\5\u00d8m\2\u0655\u0657\5\u00d4k\2\u0656\u0653\3\2\2\2\u0656\u0654"+
"\3\2\2\2\u0656\u0655\3\2\2\2\u0657\u00d3\3\2\2\2\u0658\u065a\5\u0130\u0099"+
"\2\u0659\u065b\5\u00d6l\2\u065a\u0659\3\2\2\2\u065a\u065b\3\2\2\2\u065b"+
"\u0660\3\2\2\2\u065c\u065e\7\20\2\2\u065d\u065c\3\2\2\2\u065d\u065e\3"+
"\2\2\2\u065e\u065f\3\2\2\2\u065f\u0661\5\u01de\u00f0\2\u0660\u065d\3\2"+
"\2\2\u0660\u0661\3\2\2\2\u0661\u00d5\3\2\2\2\u0662\u0663\7\u00be\2\2\u0663"+
"\u0664\7\u00c7\2\2\u0664\u00d7\3\2\2\2\u0665\u0666\7\u00c7\2\2\u0666\u0667"+
"\7\u00b8\2\2\u0667\u066a\7\u00a7\2\2\u0668\u0669\7\20\2\2\u0669\u066b"+
"\7\u00c7\2\2\u066a\u0668\3\2\2\2\u066a\u066b\3\2\2\2\u066b\u00d9\3\2\2"+
"\2\u066c\u0671\5\u0188\u00c5\2\u066d\u0671\5\u00dep\2\u066e\u0671\5\u00e0"+
"q\2\u066f\u0671\5\u00e2r\2\u0670\u066c\3\2\2\2\u0670\u066d\3\2\2\2\u0670"+
"\u066e\3\2\2\2\u0670\u066f\3\2\2\2\u0671\u0673\3\2\2\2\u0672\u0674\5\u00e4"+
"s\2\u0673\u0672\3\2\2\2\u0673\u0674\3\2\2\2\u0674\u0678\3\2\2\2\u0675"+
"\u0676\7\20\2\2\u0676\u0679\5\u01dc\u00ef\2\u0677\u0679\5\u01dc\u00ef"+
"\2\u0678\u0675\3\2\2\2\u0678\u0677\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067b"+
"\3\2\2\2\u067a\u067c\7>\2\2\u067b\u067a\3\2\2\2\u067b\u067c\3\2\2\2\u067c"+
"\u067f\3\2\2\2\u067d\u0680\7?\2\2\u067e\u0680\7@\2\2\u067f\u067d\3\2\2"+
"\2\u067f\u067e\3\2\2\2\u067f\u0680\3\2\2\2\u0680\u00db\3\2\2\2\u0681\u0682"+
"\7z\2\2\u0682\u0688\7\u00c7\2\2\u0683\u0685\7\u0093\2\2\u0684\u0686\5"+
"\u01b2\u00da\2\u0685\u0684\3\2\2\2\u0685\u0686\3\2\2\2\u0686\u0687\3\2"+
"\2\2\u0687\u0689\7\u0094\2\2\u0688\u0683\3\2\2\2\u0688\u0689\3\2\2\2\u0689"+
"\u00dd\3\2\2\2\u068a\u068e\7A\2\2\u068b\u068d\5\24\13\2\u068c\u068b\3"+
"\2\2\2\u068d\u0690\3\2\2\2\u068e\u068c\3\2\2\2\u068e\u068f\3\2\2\2\u068f"+
"\u0691\3\2\2\2\u0690\u068e\3\2\2\2\u0691\u0692\7\u0095\2\2\u0692\u0693"+
"\5\u016a\u00b6\2\u0693\u0694\7\u0096\2\2\u0694\u00df\3\2\2\2\u0695\u0696"+
"\7B\2\2\u0696\u0697\7\u0099\2\2\u0697\u0698\7\u00c7\2\2\u0698\u069b\7"+
"\u0095\2\2\u0699\u069c\7\u00c5\2\2\u069a\u069c\7\u00c4\2\2\u069b\u0699"+
"\3\2\2\2\u069b\u069a\3\2\2\2\u069c\u06a2\3\2\2\2\u069d\u06a0\7C\2\2\u069e"+
"\u06a1\7\u00c5\2\2\u069f\u06a1\7\u00c4\2\2\u06a0\u069e\3\2\2\2\u06a0\u069f"+
"\3\2\2\2\u06a1\u06a3\3\2\2\2\u06a2\u069d\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
"\u06a4\3\2\2\2\u06a4\u06a5\7\u0096\2\2\u06a5\u00e1\3\2\2\2\u06a6\u06a7"+
"\7\u00c7\2\2\u06a7\u06a8\7\u0099\2\2\u06a8\u06ae\5\u01a4\u00d3\2\u06a9"+
"\u06ab\7\u0093\2\2\u06aa\u06ac\5\u01b2\u00da\2\u06ab\u06aa\3\2\2\2\u06ab"+
"\u06ac\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06af\7\u0094\2\2\u06ae\u06a9"+
"\3\2\2\2\u06ae\u06af\3\2\2\2\u06af\u06b1\3\2\2\2\u06b0\u06b2\5\u0196\u00cc"+
"\2\u06b1\u06b0\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2\u00e3\3\2\2\2\u06b3\u06b4"+
"\7\u00b8\2\2\u06b4\u06b9\5\u00e6t\2\u06b5\u06b6\7\u00b8\2\2\u06b6\u06b8"+
"\5\u00e6t\2\u06b7\u06b5\3\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2"+
"\2\u06b9\u06ba\3\2\2\2\u06ba\u06c6\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06bd"+
"\7\u00bf\2\2\u06bd\u06c2\5\u00e8u\2\u06be\u06bf\7\u00bf\2\2\u06bf\u06c1"+
"\5\u00e8u\2\u06c0\u06be\3\2\2\2\u06c1\u06c4\3\2\2\2\u06c2\u06c0\3\2\2"+
"\2\u06c2\u06c3\3\2\2\2\u06c3\u06c6\3\2\2\2\u06c4\u06c2\3\2\2\2\u06c5\u06b3"+
"\3\2\2\2\u06c5\u06bc\3\2\2\2\u06c6\u00e5\3\2\2\2\u06c7\u06c8\7\u00c7\2"+
"\2\u06c8\u06c9\7\u0099\2\2\u06c9\u06ca\5\u00eav\2\u06ca\u00e7\3\2\2\2"+
"\u06cb\u06cc\7\u00c7\2\2\u06cc\u06ce\7\u0099\2\2\u06cd\u06cb\3\2\2\2\u06cd"+
"\u06ce\3\2\2\2\u06ce\u06cf\3\2\2\2\u06cf\u06d0\5\u00eav\2\u06d0\u00e9"+
"\3\2\2\2\u06d1\u06d4\7\u00c7\2\2\u06d2\u06d4\7}\2\2\u06d3\u06d1\3\2\2"+
"\2\u06d3\u06d2\3\2\2\2\u06d4\u06da\3\2\2\2\u06d5\u06d7\7\u0093\2\2\u06d6"+
"\u06d8\5\u01b4\u00db\2\u06d7\u06d6\3\2\2\2\u06d7\u06d8\3\2\2\2\u06d8\u06d9"+
"\3\2\2\2\u06d9\u06db\7\u0094\2\2\u06da\u06d5\3\2\2\2\u06da\u06db\3\2\2"+
"\2\u06db\u00eb\3\2\2\2\u06dc\u06e1\5\u00eex\2\u06dd\u06de\7\u009a\2\2"+
"\u06de\u06e0\5\u00eex\2\u06df\u06dd\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1"+
"\u06df\3\2\2\2\u06e1\u06e2\3\2\2\2\u06e2\u00ed\3\2\2\2\u06e3\u06e1\3\2"+
"\2\2\u06e4\u06e8\5\u0130\u0099\2\u06e5\u06e8\5\u00f0y\2\u06e6\u06e8\5"+
"\u00f2z\2\u06e7\u06e4\3\2\2\2\u06e7\u06e5\3\2\2\2\u06e7\u06e6\3\2\2\2"+
"\u06e8\u00ef\3\2\2\2\u06e9\u06ea\t\5\2\2\u06ea\u06eb\7\u0093\2\2\u06eb"+
"\u06f0\5\u00f6|\2\u06ec\u06ed\7\u009a\2\2\u06ed\u06ef\5\u00f6|\2\u06ee"+
"\u06ec\3\2\2\2\u06ef\u06f2\3\2\2\2\u06f0\u06ee\3\2\2\2\u06f0\u06f1\3\2"+
"\2\2\u06f1\u06f3\3\2\2\2\u06f2\u06f0\3\2\2\2\u06f3\u06f4\7\u0094\2\2\u06f4"+
"\u00f1\3\2\2\2\u06f5\u06f6\7\u0089\2\2\u06f6\u06f7\7\u008b\2\2\u06f7\u06f8"+
"\7\u0093\2\2\u06f8\u06fd\5\u00f4{\2\u06f9\u06fa\7\u009a\2\2\u06fa\u06fc"+
"\5\u00f4{\2\u06fb\u06f9\3\2\2\2\u06fc\u06ff\3\2\2\2\u06fd\u06fb\3\2\2"+
"\2\u06fd\u06fe\3\2\2\2\u06fe\u0700\3\2\2\2\u06ff\u06fd\3\2\2\2\u0700\u0701"+
"\7\u0094\2\2\u0701\u00f3\3\2\2\2\u0702\u0705\5\u00f0y\2\u0703\u0705\5"+
"\u00f6|\2\u0704\u0702\3\2\2\2\u0704\u0703\3\2\2\2\u0705\u00f5\3\2\2\2"+
"\u0706\u0714\5\u0130\u0099\2\u0707\u0710\7\u0093\2\2\u0708\u070d\5\u0130"+
"\u0099\2\u0709\u070a\7\u009a\2\2\u070a\u070c\5\u0130\u0099\2\u070b\u0709"+
"\3\2\2\2\u070c\u070f\3\2\2\2\u070d\u070b\3\2\2\2\u070d\u070e\3\2\2\2\u070e"+
"\u0711\3\2\2\2\u070f\u070d\3\2\2\2\u0710\u0708\3\2\2\2\u0710\u0711\3\2"+
"\2\2\u0711\u0712\3\2\2\2\u0712\u0714\7\u0094\2\2\u0713\u0706\3\2\2\2\u0713"+
"\u0707\3\2\2\2\u0714\u00f7\3\2\2\2\u0715\u071a\5\u00fa~\2\u0716\u0717"+
"\7\u009a\2\2\u0717\u0719\5\u00fa~\2\u0718\u0716\3\2\2\2\u0719\u071c\3"+
"\2\2\2\u071a\u0718\3\2\2\2\u071a\u071b\3\2\2\2\u071b\u00f9\3\2\2\2\u071c"+
"\u071a\3\2\2\2\u071d\u0720\5\u0130\u0099\2\u071e\u0721\78\2\2\u071f\u0721"+
"\79\2\2\u0720\u071e\3\2\2\2\u0720\u071f\3\2\2\2\u0720\u0721\3\2\2\2\u0721"+
"\u00fb\3\2\2\2\u0722\u0723\5\u0134\u009b\2\u0723\u00fd\3\2\2\2\u0724\u0726"+
"\5\u0102\u0082\2\u0725\u0724\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u072b\3"+
"\2\2\2\u0727\u072c\7-\2\2\u0728\u072c\7\62\2\2\u0729\u072c\7\63\2\2\u072a"+
"\u072c\7Q\2\2\u072b\u0727\3\2\2\2\u072b\u0728\3\2\2\2\u072b\u0729\3\2"+
"\2\2\u072b\u072a\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u0749\3\2\2\2\u072d"+
"\u0734\7\r\2\2\u072e\u0735\5\u01e4\u00f3\2\u072f\u0732\5\u01f8\u00fd\2"+
"\u0730\u0732\7\u00c7\2\2\u0731\u072f\3\2\2\2\u0731\u0730\3\2\2\2\u0732"+
"\u0733\3\2\2\2\u0733\u0735\7\61\2\2\u0734\u072e\3\2\2\2\u0734\u0731\3"+
"\2\2\2\u0735\u074a\3\2\2\2\u0736\u0737\7V\2\2\u0737\u074a\5\u0108\u0085"+
"\2\u0738\u0739\7\35\2\2\u0739\u073c\5\u0130\u0099\2\u073a\u073b\7\36\2"+
"\2\u073b\u073d\5H%\2\u073c\u073a\3\2\2\2\u073c\u073d\3\2\2\2\u073d\u074a"+
"\3\2\2\2\u073e\u073f\7\35\2\2\u073f\u0742\7\u0085\2\2\u0740\u0741\7\13"+
"\2\2\u0741\u0743\5\u0130\u0099\2\u0742\u0740\3\2\2\2\u0742\u0743\3\2\2"+
"\2\u0743\u0746\3\2\2\2\u0744\u0745\7\36\2\2\u0745\u0747\5H%\2\u0746\u0744"+
"\3\2\2\2\u0746\u0747\3\2\2\2\u0747\u074a\3\2\2\2\u0748\u074a\3\2\2\2\u0749"+
"\u072d\3\2\2\2\u0749\u0736\3\2\2\2\u0749\u0738\3\2\2\2\u0749\u073e\3\2"+
"\2\2\u0749\u0748\3\2\2\2\u074a\u074c\3\2\2\2\u074b\u074d\5\u0100\u0081"+
"\2\u074c\u074b\3\2\2\2\u074c\u074d\3\2\2\2\u074d\u00ff\3\2\2\2\u074e\u074f"+
"\7\13\2\2\u074f\u0750\7\35\2\2\u0750\u0753\7\u0085\2\2\u0751\u0752\7\13"+
"\2\2\u0752\u0754\5\u0130\u0099\2\u0753\u0751\3\2\2\2\u0753\u0754\3\2\2"+
"\2\u0754\u0757\3\2\2\2\u0755\u0756\7\36\2\2\u0756\u0758\5H%\2\u0757\u0755"+
"\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u0101\3\2\2\2\u0759\u075e\7y\2\2\u075a"+
"\u075f\5\u01e4\u00f3\2\u075b\u075c\5\u01f8\u00fd\2\u075c\u075d\7\61\2"+
"\2\u075d\u075f\3\2\2\2\u075e\u075a\3\2\2\2\u075e\u075b\3\2\2\2\u075f\u0103"+
"\3\2\2\2\u0760\u0763\5\u0200\u0101\2\u0761\u0763\7\u00c7\2\2\u0762\u0760"+
"\3\2\2\2\u0762\u0761\3\2\2\2\u0763\u076c\3\2\2\2\u0764\u0767\7\u009a\2"+
"\2\u0765\u0767\7q\2\2\u0766\u0764\3\2\2\2\u0766\u0765\3\2\2\2\u0767\u076a"+
"\3\2\2\2\u0768\u076b\5\u0200\u0101\2\u0769\u076b\7\u00c7\2\2\u076a\u0768"+
"\3\2\2\2\u076a\u0769\3\2\2\2\u076b\u076d\3\2\2\2\u076c\u0766\3\2\2\2\u076c"+
"\u076d\3\2\2\2\u076d\u0105\3\2\2\2\u076e\u0773\5\u0108\u0085\2\u076f\u0770"+
"\7\u009a\2\2\u0770\u0772\5\u0108\u0085\2\u0771\u076f\3\2\2\2\u0772\u0775"+
"\3\2\2\2\u0773\u0771\3\2\2\2\u0773\u0774\3\2\2\2\u0774\u0107\3\2\2\2\u0775"+
"\u0773\3\2\2\2\u0776\u0777\7\u0093\2\2\u0777\u0778\5\u01b4\u00db\2\u0778"+
"\u0779\7\u0094\2\2\u0779\u0109\3\2\2\2\u077a\u077b\7\35\2\2\u077b\u077c"+
"\5\u0130\u0099\2\u077c\u077d\7\36\2\2\u077d\u077e\5\u0130\u0099\2\u077e"+
"\u010b\3\2\2\2\u077f\u0780\7\34\2\2\u0780\u0781\5\u0130\u0099\2\u0781"+
"\u010d\3\2\2\2\u0782\u0783\7s\2\2\u0783\u0785\7\u0093\2\2\u0784\u0786"+
"\5\u0110\u0089\2\u0785\u0784\3\2\2\2\u0785\u0786\3\2\2\2\u0786\u0787\3"+
"\2\2\2\u0787\u0789\5\u0112\u008a\2\u0788\u078a\5\u0116\u008c\2\u0789\u0788"+
"\3\2\2\2\u0789\u078a\3\2\2\2\u078a\u078c\3\2\2\2\u078b\u078d\5\u011a\u008e"+
"\2\u078c\u078b\3\2\2\2\u078c\u078d\3\2\2\2\u078d\u078e\3\2\2\2\u078e\u0790"+
"\5\u0118\u008d\2\u078f\u0791\5\u011c\u008f\2\u0790\u078f\3\2\2\2\u0790"+
"\u0791\3\2\2\2\u0791\u0793\3\2\2\2\u0792\u0794\5\u012c\u0097\2\u0793\u0792"+
"\3\2\2\2\u0793\u0794\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\7\u0094\2"+
"\2\u0796\u010f\3\2\2\2\u0797\u0798\7w\2\2\u0798\u0799\7)\2\2\u0799\u079e"+
"\5\u0130\u0099\2\u079a\u079b\7\u009a\2\2\u079b\u079d\5\u0130\u0099\2\u079c"+
"\u079a\3\2\2\2\u079d\u07a0\3\2\2\2\u079e\u079c\3\2\2\2\u079e\u079f\3\2"+
"\2\2\u079f\u0111\3\2\2\2\u07a0\u079e\3\2\2\2\u07a1\u07a2\7u\2\2\u07a2"+
"\u07a7\5\u0114\u008b\2\u07a3\u07a4\7\u009a\2\2\u07a4\u07a6\5\u0114\u008b"+
"\2\u07a5\u07a3\3\2\2\2\u07a6\u07a9\3\2\2\2\u07a7\u07a5\3\2\2\2\u07a7\u07a8"+
"\3\2\2\2\u07a8\u0113\3\2\2\2\u07a9\u07a7\3\2\2\2\u07aa\u07af\5\u0130\u0099"+
"\2\u07ab\u07ad\7\20\2\2\u07ac\u07ae\7\u00c7\2\2\u07ad\u07ac\3\2\2\2\u07ad"+
"\u07ae\3\2\2\2\u07ae\u07b0\3\2\2\2\u07af\u07ab\3\2\2\2\u07af\u07b0\3\2"+
"\2\2\u07b0\u0115\3\2\2\2\u07b1\u07b2\7-\2\2\u07b2\u07b3\7x\2\2\u07b3\u0117"+
"\3\2\2\2\u07b4\u07b5\7A\2\2\u07b5\u07b6\7\u0093\2\2\u07b6\u07b7\5\u011e"+
"\u0090\2\u07b7\u07b8\7\u0094\2\2\u07b8\u0119\3\2\2\2\u07b9\u07ba\7y\2"+
"\2\u07ba\u07bb\5\u01de\u00f0\2\u07bb\u07bc\5\u01de\u00f0\2\u07bc\u07bd"+
"\5\u01de\u00f0\2\u07bd\u07be\5\u01de\u00f0\2\u07be\u07bf\5\u01de\u00f0"+
"\2\u07bf\u011b\3\2\2\2\u07c0\u07c1\7\u00c7\2\2\u07c1\u07c4\5\u01e4\u00f3"+
"\2\u07c2\u07c3\7\n\2\2\u07c3\u07c5\7\u0085\2\2\u07c4\u07c2\3\2\2\2\u07c4"+
"\u07c5\3\2\2\2\u07c5\u011d\3\2\2\2\u07c6\u07cb\5\u0120\u0091\2\u07c7\u07c8"+
"\7\u00b1\2\2\u07c8\u07ca\5\u0120\u0091\2\u07c9\u07c7\3\2\2\2\u07ca\u07cd"+
"\3\2\2\2\u07cb\u07c9\3\2\2\2\u07cb\u07cc\3\2\2\2\u07cc\u011f\3\2\2\2\u07cd"+
"\u07cb\3\2\2\2\u07ce\u07d0\5\u0122\u0092\2\u07cf\u07ce\3\2\2\2\u07d0\u07d1"+
"\3\2\2\2\u07d1\u07cf\3\2\2\2\u07d1\u07d2\3\2\2\2\u07d2\u0121\3\2\2\2\u07d3"+
"\u07d7\5\u0126\u0094\2\u07d4\u07d7\5\u0124\u0093\2\u07d5\u07d7\5\u0128"+
"\u0095\2\u07d6\u07d3\3\2\2\2\u07d6\u07d4\3\2\2\2\u07d6\u07d5\3\2\2\2\u07d7"+
"\u0123\3\2\2\2\u07d8\u07d9\7\u0093\2\2\u07d9\u07da\5\u011e\u0090\2\u07da"+
"\u07de\7\u0094\2\2\u07db\u07df\7\u00a7\2\2\u07dc\u07df\7\u00a1\2\2\u07dd"+
"\u07df\7\u0092\2\2\u07de\u07db\3\2\2\2\u07de\u07dc\3\2\2\2\u07de\u07dd"+
"\3\2\2\2\u07de\u07df\3\2\2\2\u07df\u07e1\3\2\2\2\u07e0\u07e2\5\u012a\u0096"+
"\2\u07e1\u07e0\3\2\2\2\u07e1\u07e2\3\2\2\2\u07e2\u0125\3\2\2\2\u07e3\u07e4"+
"\7t\2\2\u07e4\u07e5\7\u0093\2\2\u07e5\u07ea\5\u011e\u0090\2\u07e6\u07e7"+
"\7\u009a\2\2\u07e7\u07e9\5\u011e\u0090\2\u07e8\u07e6\3\2\2\2\u07e9\u07ec"+
"\3\2\2\2\u07ea\u07e8\3\2\2\2\u07ea\u07eb\3\2\2\2\u07eb\u07ed\3\2\2\2\u07ec"+
"\u07ea\3\2\2\2\u07ed\u07ee\7\u0094\2\2\u07ee\u0127\3\2\2\2\u07ef\u07f8"+
"\7\u00c7\2\2\u07f0\u07f4\7\u00a7\2\2\u07f1\u07f4\7\u00a1\2\2\u07f2\u07f4"+
"\7\u0092\2\2\u07f3\u07f0\3\2\2\2\u07f3\u07f1\3\2\2\2\u07f3\u07f2\3\2\2"+
"\2\u07f4\u07f6\3\2\2\2\u07f5\u07f7\7\u0092\2\2\u07f6\u07f5\3\2\2\2\u07f6"+
"\u07f7\3\2\2\2\u07f7\u07f9\3\2\2\2\u07f8\u07f3\3\2\2\2\u07f8\u07f9\3\2"+
"\2\2\u07f9\u07fb\3\2\2\2\u07fa\u07fc\5\u012a\u0096\2\u07fb\u07fa\3\2\2"+
"\2\u07fb\u07fc\3\2\2\2\u07fc\u0129\3\2\2\2\u07fd\u07ff\7\u0097\2\2\u07fe"+
"\u0800\5\u0130\u0099\2\u07ff\u07fe\3\2\2\2\u07ff\u0800\3\2\2\2\u0800\u0802"+
"\3\2\2\2\u0801\u0803\7\u009a\2\2\u0802\u0801\3\2\2\2\u0802\u0803\3\2\2"+
"\2\u0803\u0805\3\2\2\2\u0804\u0806\5\u0130\u0099\2\u0805\u0804\3\2\2\2"+
"\u0805\u0806\3\2\2\2\u0806\u0807\3\2\2\2\u0807\u0808\7\u0098\2\2\u0808"+
"\u012b\3\2\2\2\u0809\u080a\7v\2\2\u080a\u080f\5\u012e\u0098\2\u080b\u080c"+
"\7\u009a\2\2\u080c\u080e\5\u012e\u0098\2\u080d\u080b\3\2\2\2\u080e\u0811"+
"\3\2\2\2\u080f\u080d\3\2\2\2\u080f\u0810\3\2\2\2\u0810\u012d\3\2\2\2\u0811"+
"\u080f\3\2\2\2\u0812\u0813\7\u00c7\2\2\u0813\u0814\7\20\2\2\u0814\u0815"+
"\5\u0130\u0099\2\u0815\u012f\3\2\2\2\u0816\u0817\5\u0132\u009a\2\u0817"+
"\u0131\3\2\2\2\u0818\u0819\b\u009a\1\2\u0819\u081b\7\33\2\2\u081a\u081c"+
"\5\u010a\u0086\2\u081b\u081a\3\2\2\2\u081c\u081d\3\2\2\2\u081d\u081b\3"+
"\2\2\2\u081d\u081e\3\2\2\2\u081e\u0820\3\2\2\2\u081f\u0821\5\u010c\u0087"+
"\2\u0820\u081f\3\2\2\2\u0820\u0821\3\2\2\2\u0821\u0822\3\2\2\2\u0822\u0823"+
"\7\37\2\2\u0823\u0824\b\u009a\1\2\u0824\u0835\3\2\2\2\u0825\u0826\b\u009a"+
"\1\2\u0826\u0827\7\33\2\2\u0827\u0829\5\u0130\u0099\2\u0828\u082a\5\u010a"+
"\u0086\2\u0829\u0828\3\2\2\2\u082a\u082b\3\2\2\2\u082b\u0829\3\2\2\2\u082b"+
"\u082c\3\2\2\2\u082c\u082e\3\2\2\2\u082d\u082f\5\u010c\u0087\2\u082e\u082d"+
"\3\2\2\2\u082e\u082f\3\2\2\2\u082f\u0830\3\2\2\2\u0830\u0831\7\37\2\2"+
"\u0831\u0832\b\u009a\1\2\u0832\u0835\3\2\2\2\u0833\u0835\5\u0134\u009b"+
"\2\u0834\u0818\3\2\2\2\u0834\u0825\3\2\2\2\u0834\u0833\3\2\2\2\u0835\u0133"+
"\3\2\2\2\u0836\u083b\5\u0136\u009c\2\u0837\u0838\7\n\2\2\u0838\u083a\5"+
"\u0136\u009c\2\u0839\u0837\3\2\2\2\u083a\u083d\3\2\2\2\u083b\u0839\3\2"+
"\2\2\u083b\u083c\3\2\2\2\u083c\u0135\3\2\2\2\u083d\u083b\3\2\2\2\u083e"+
"\u0843\5\u0138\u009d\2\u083f\u0840\7\13\2\2\u0840\u0842\5\u0138\u009d"+
"\2\u0841\u083f\3\2\2\2\u0842\u0845\3\2\2\2\u0843\u0841\3\2\2\2\u0843\u0844"+
"\3\2\2\2\u0844\u0137\3\2\2\2\u0845\u0843\3\2\2\2\u0846\u084b\5\u013a\u009e"+
"\2\u0847\u0848\t\6\2\2\u0848\u084a\5\u013a\u009e\2\u0849\u0847\3\2\2\2"+
"\u084a\u084d\3\2\2\2\u084b\u0849\3\2\2\2\u084b\u084c\3\2\2\2\u084c\u0139"+
"\3\2\2\2\u084d\u084b\3\2\2\2\u084e\u0852\5\u013c\u009f\2\u084f\u0850\7"+
"\f\2\2\u0850\u0852\5\u013c\u009f\2\u0851\u084e\3\2\2\2\u0851\u084f\3\2"+
"\2\2\u0852\u013b\3\2\2\2\u0853\u086e\5\u013e\u00a0\2\u0854\u085b\7\u0090"+
"\2\2\u0855\u085b\7(\2\2\u0856\u0857\7(\2\2\u0857\u085b\7\f\2\2\u0858\u085b"+
"\7\u0091\2\2\u0859\u085b\7\u009e\2\2\u085a\u0854\3\2\2\2\u085a\u0855\3"+
"\2\2\2\u085a\u0856\3\2\2\2\u085a\u0858\3\2\2\2\u085a\u0859\3\2\2\2\u085b"+
"\u086a\3\2\2\2\u085c\u086b\5\u013e\u00a0\2\u085d\u0861\7.\2\2\u085e\u0861"+
"\7/\2\2\u085f\u0861\7-\2\2\u0860\u085d\3\2\2\2\u0860\u085e\3\2\2\2\u0860"+
"\u085f\3\2\2\2\u0861\u0868\3\2\2\2\u0862\u0864\7\u0093\2\2\u0863\u0865"+
"\5\u01b2\u00da\2\u0864\u0863\3\2\2\2\u0864\u0865\3\2\2\2\u0865\u0866\3"+
"\2\2\2\u0866\u0869\7\u0094\2\2\u0867\u0869\5\u0152\u00aa\2\u0868\u0862"+
"\3\2\2\2\u0868\u0867\3\2\2\2\u0869\u086b\3\2\2\2\u086a\u085c\3\2\2\2\u086a"+
"\u0860\3\2\2\2\u086b\u086d\3\2\2\2\u086c\u085a\3\2\2\2\u086d\u0870\3\2"+
"\2\2\u086e\u086c\3\2\2\2\u086e\u086f\3\2\2\2\u086f\u013d\3\2\2\2\u0870"+
"\u086e\3\2\2\2\u0871\u08b3\5\u0142\u00a2\2\u0872\u0877\7\u00ae\2\2\u0873"+
"\u0877\7\u00ac\2\2\u0874\u0877\7\u00ad\2\2\u0875\u0877\7\u00ab\2\2\u0876"+
"\u0872\3\2\2\2\u0876\u0873\3\2\2\2\u0876\u0874\3\2\2\2\u0876\u0875\3\2"+
"\2\2\u0877\u0886\3\2\2\2\u0878\u0887\5\u0142\u00a2\2\u0879\u087d\7.\2"+
"\2\u087a\u087d\7/\2\2\u087b\u087d\7-\2\2\u087c\u0879\3\2\2\2\u087c\u087a"+
"\3\2\2\2\u087c\u087b\3\2\2\2\u087d\u0884\3\2\2\2\u087e\u0880\7\u0093\2"+
"\2\u087f\u0881\5\u01b2\u00da\2\u0880\u087f\3\2\2\2\u0880\u0881\3\2\2\2"+
"\u0881\u0882\3\2\2\2\u0882\u0885\7\u0094\2\2\u0883\u0885\5\u0152\u00aa"+
"\2\u0884\u087e\3\2\2\2\u0884\u0883\3\2\2\2\u0885\u0887\3\2\2\2\u0886\u0878"+
"\3\2\2\2\u0886\u087c\3\2\2\2\u0887\u0889\3\2\2\2\u0888\u0876\3\2\2\2\u0889"+
"\u088c\3\2\2\2\u088a\u0888\3\2\2\2\u088a\u088b\3\2\2\2\u088b\u08b4\3\2"+
"\2\2\u088c\u088a\3\2\2\2\u088d\u088f\7\f\2\2\u088e\u088d\3\2\2\2\u088e"+
"\u088f\3\2\2\2\u088f\u08b1\3\2\2\2\u0890\u0893\7\5\2\2\u0891\u0894\7\u0093"+
"\2\2\u0892\u0894\7\u0095\2\2\u0893\u0891\3\2\2\2\u0893\u0892\3\2\2\2\u0894"+
"\u0895\3\2\2\2\u0895\u089f\5\u0130\u0099\2\u0896\u0897\7\u0099\2\2\u0897"+
"\u08a0\5\u0130\u0099\2\u0898\u0899\7\u009a\2\2\u0899\u089b\5\u0130\u0099"+
"\2\u089a\u0898\3\2\2\2\u089b\u089e\3\2\2\2\u089c\u089a\3\2\2\2\u089c\u089d"+
"\3\2\2\2\u089d\u08a0\3\2\2\2\u089e\u089c\3\2\2\2\u089f\u0896\3\2\2\2\u089f"+
"\u089c\3\2\2\2\u08a0\u08a3\3\2\2\2\u08a1\u08a4\7\u0094\2\2\u08a2\u08a4"+
"\7\u0096\2\2\u08a3\u08a1\3\2\2\2\u08a3\u08a2\3\2\2\2\u08a4\u08b2\3\2\2"+
"\2\u08a5\u08a6\7\5\2\2\u08a6\u08b2\5\u0140\u00a1\2\u08a7\u08a8\7\6\2\2"+
"\u08a8\u08b2\5\u0168\u00b5\2\u08a9\u08aa\7\7\2\2\u08aa\u08ad\5\u0142\u00a2"+
"\2\u08ab\u08ac\7\t\2\2\u08ac\u08ae\5\u0202\u0102\2\u08ad\u08ab\3\2\2\2"+
"\u08ad\u08ae\3\2\2\2\u08ae\u08b2\3\2\2\2\u08af\u08b0\7\b\2\2\u08b0\u08b2"+
"\5\u0142\u00a2\2\u08b1\u0890\3\2\2\2\u08b1\u08a5\3\2\2\2\u08b1\u08a7\3"+
"\2\2\2\u08b1\u08a9\3\2\2\2\u08b1\u08af\3\2\2\2\u08b2\u08b4\3\2\2\2\u08b3"+
"\u088a\3\2\2\2\u08b3\u088e\3\2\2\2\u08b4\u013f\3\2\2\2\u08b5\u08b6\5\u0156"+
"\u00ac\2\u08b6\u0141\3\2\2\2\u08b7\u08c1\5\u0144\u00a3\2\u08b8\u08b9\7"+
"\u00b3\2\2\u08b9\u08be\5\u0144\u00a3\2\u08ba\u08bb\7\u00b3\2\2\u08bb\u08bd"+
"\5\u0144\u00a3\2\u08bc\u08ba\3\2\2\2\u08bd\u08c0\3\2\2\2\u08be\u08bc\3"+
"\2\2\2\u08be\u08bf\3\2\2\2\u08bf\u08c2\3\2\2\2\u08c0\u08be\3\2\2\2\u08c1"+
"\u08b8\3\2\2\2\u08c1\u08c2\3\2\2\2\u08c2\u0143\3\2\2\2\u08c3\u08c8\5\u0146"+
"\u00a4\2\u08c4\u08c5\t\7\2\2\u08c5\u08c7\5\u0146\u00a4\2\u08c6\u08c4\3"+
"\2\2\2\u08c7\u08ca\3\2\2\2\u08c8\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9"+
"\u0145\3\2\2\2\u08ca\u08c8\3\2\2\2\u08cb\u08d0\5\u0148\u00a5\2\u08cc\u08cd"+
"\t\b\2\2\u08cd";
private static final String _serializedATNSegment1 =
"\u08cf\5\u0148\u00a5\2\u08ce\u08cc\3\2\2\2\u08cf\u08d2\3\2\2\2\u08d0\u08ce"+
"\3\2\2\2\u08d0\u08d1\3\2\2\2\u08d1\u0147\3\2\2\2\u08d2\u08d0\3\2\2\2\u08d3"+
"\u0914\5\u014a\u00a6\2\u08d4\u0914\5\u01fe\u0100\2\u08d5\u0914\5\u014c"+
"\u00a7\2\u08d6\u08d7\7\u0093\2\2\u08d7\u08d8\5\u0130\u0099\2\u08d8\u08d9"+
"\7\u0094\2\2\u08d9\u08da\5\u01d0\u00e9\2\u08da\u0914\3\2\2\2\u08db\u0914"+
"\5\u015c\u00af\2\u08dc\u0914\5\u01cc\u00e7\2\u08dd\u0914\5\u015a\u00ae"+
"\2\u08de\u0914\5\u0150\u00a9\2\u08df\u0914\5\u0154\u00ab\2\u08e0\u08e1"+
"\7\u0081\2\2\u08e1\u08e2\7\u0097\2\2\u08e2\u08e7\5\u014e\u00a8\2\u08e3"+
"\u08e4\7\u009a\2\2\u08e4\u08e6\5\u014e\u00a8\2\u08e5\u08e3\3\2\2\2\u08e6"+
"\u08e9\3\2\2\2\u08e7\u08e5\3\2\2\2\u08e7\u08e8\3\2\2\2\u08e8\u08ea\3\2"+
"\2\2\u08e9\u08e7\3\2\2\2\u08ea\u08eb\7\u0098\2\2\u08eb\u0914\3\2\2\2\u08ec"+
"\u08ed\7\u0081\2\2\u08ed\u08ee\5\u019c\u00cf\2\u08ee\u08f7\7\u0093\2\2"+
"\u08ef\u08f4\5\u0130\u0099\2\u08f0\u08f1\7\u009a\2\2\u08f1\u08f3\5\u0130"+
"\u0099\2\u08f2\u08f0\3\2\2\2\u08f3\u08f6\3\2\2\2\u08f4\u08f2\3\2\2\2\u08f4"+
"\u08f5\3\2\2\2\u08f5\u08f8\3\2\2\2\u08f6\u08f4\3\2\2\2\u08f7\u08ef\3\2"+
"\2\2\u08f7\u08f8\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9\u08fa\7\u0094\2\2\u08fa"+
"\u08fb\5\u01d0\u00e9\2\u08fb\u0914\3\2\2\2\u08fc\u08fd\7\u0081\2\2\u08fd"+
"\u08fe\5\u019c\u00cf\2\u08fe\u08ff\7\u0095\2\2\u08ff\u0900\5\u0130\u0099"+
"\2\u0900\u0906\7\u0096\2\2\u0901\u0903\7\u0095\2\2\u0902\u0904\5\u0130"+
"\u0099\2\u0903\u0902\3\2\2\2\u0903\u0904\3\2\2\2\u0904\u0905\3\2\2\2\u0905"+
"\u0907\7\u0096\2\2\u0906\u0901\3\2\2\2\u0906\u0907\3\2\2\2\u0907\u0914"+
"\3\2\2\2\u0908\u0909\7\u0081\2\2\u0909\u090a\5\u019c\u00cf\2\u090a\u090b"+
"\7\u0095\2\2\u090b\u090e\7\u0096\2\2\u090c\u090d\7\u0095\2\2\u090d\u090f"+
"\7\u0096\2\2\u090e\u090c\3\2\2\2\u090e\u090f\3\2\2\2\u090f\u0910\3\2\2"+
"\2\u0910\u0911\5\u015a\u00ae\2\u0911\u0914\3\2\2\2\u0912\u0914\5\u0206"+
"\u0104\2\u0913\u08d3\3\2\2\2\u0913\u08d4\3\2\2\2\u0913\u08d5\3\2\2\2\u0913"+
"\u08d6\3\2\2\2\u0913\u08db\3\2\2\2\u0913\u08dc\3\2\2\2\u0913\u08dd\3\2"+
"\2\2\u0913\u08de\3\2\2\2\u0913\u08df\3\2\2\2\u0913\u08e0\3\2\2\2\u0913"+
"\u08ec\3\2\2\2\u0913\u08fc\3\2\2\2\u0913\u0908\3\2\2\2\u0913\u0912\3\2"+
"\2\2\u0914\u0149\3\2\2\2\u0915\u0916\7\u00a4\2\2\u0916\u0917\5\u01cc\u00e7"+
"\2\u0917\u014b\3\2\2\2\u0918\u0919\5\u01fa\u00fe\2\u0919\u091a\5\u01d0"+
"\u00e9\2\u091a\u014d\3\2\2\2\u091b\u091e\5\u01cc\u00e7\2\u091c\u091d\7"+
"\u0090\2\2\u091d\u091f\5\u0130\u0099\2\u091e\u091c\3\2\2\2\u091e\u091f"+
"\3\2\2\2\u091f\u014f\3\2\2\2\u0920\u0921\5\u0156\u00ac\2\u0921\u0922\5"+
"\u01d0\u00e9\2\u0922\u0151\3\2\2\2\u0923\u0924\5\u0156\u00ac\2\u0924\u0153"+
"\3\2\2\2\u0925\u0926\7I\2\2\u0926\u0927\5\u0156\u00ac\2\u0927\u0155\3"+
"\2\2\2\u0928\u0929\7\u0093\2\2\u0929\u092b\7\32\2\2\u092a\u092c\7,\2\2"+
"\u092b\u092a\3\2\2\2\u092b\u092c\3\2\2\2\u092c\u092d\3\2\2\2\u092d\u092e"+
"\5\u00d0i\2\u092e\u092f\7 \2\2\u092f\u0932\5\u0158\u00ad\2\u0930\u0931"+
"\7\17\2\2\u0931\u0933\5\u00ccg\2\u0932\u0930\3\2\2\2\u0932\u0933\3\2\2"+
"\2\u0933\u0937\3\2\2\2\u0934\u0935\7*\2\2\u0935\u0936\7)\2\2\u0936\u0938"+
"\5\u00ecw\2\u0937\u0934\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u093b\3\2\2"+
"\2\u0939\u093a\7+\2\2\u093a\u093c\5\u00fc\177\2\u093b\u0939\3\2\2\2\u093b"+
"\u093c\3\2\2\2\u093c\u093d\3\2\2\2\u093d\u093e\7\u0094\2\2\u093e\u0157"+
"\3\2\2\2\u093f\u0941\5\u0188\u00c5\2\u0940\u0942\5\u00e4s\2\u0941\u0940"+
"\3\2\2\2\u0941\u0942\3\2\2\2\u0942\u0946\3\2\2\2\u0943\u0944\7\20\2\2"+
"\u0944\u0947\5\u01dc\u00ef\2\u0945\u0947\5\u01dc\u00ef\2\u0946\u0943\3"+
"\2\2\2\u0946\u0945\3\2\2\2\u0946\u0947\3\2\2\2\u0947\u094a\3\2\2\2\u0948"+
"\u094b\7?\2\2\u0949\u094b\7@\2\2\u094a\u0948\3\2\2\2\u094a\u0949\3\2\2"+
"\2\u094a\u094b\3\2\2\2\u094b\u0159\3\2\2\2\u094c\u0955\7\u0097\2\2\u094d"+
"\u0952\5\u0130\u0099\2\u094e\u094f\7\u009a\2\2\u094f\u0951\5\u0130\u0099"+
"\2\u0950\u094e\3\2\2\2\u0951\u0954\3\2\2\2\u0952\u0950\3\2\2\2\u0952\u0953"+
"\3\2\2\2\u0953\u0956\3\2\2\2\u0954\u0952\3\2\2\2\u0955\u094d\3\2\2\2\u0955"+
"\u0956\3\2\2\2\u0956\u0957\3\2\2\2\u0957\u0958\7\u0098\2\2\u0958\u0959"+
"\5\u01d0\u00e9\2\u0959\u015b\3\2\2\2\u095a\u095b\7\21\2\2\u095b\u095d"+
"\7\u0093\2\2\u095c\u095e\t\t\2\2\u095d\u095c\3\2\2\2\u095d\u095e\3\2\2"+
"\2\u095e\u095f\3\2\2\2\u095f\u0960\5\u01a6\u00d4\2\u0960\u0961\7\u0094"+
"\2\2\u0961\u09f8\3\2\2\2\u0962\u0963\7\22\2\2\u0963\u0965\7\u0093\2\2"+
"\u0964\u0966\t\t\2\2\u0965\u0964\3\2\2\2\u0965\u0966\3\2\2\2\u0966\u0967"+
"\3\2\2\2\u0967\u0968\5\u01a6\u00d4\2\u0968\u0969\7\u0094\2\2\u0969\u09f8"+
"\3\2\2\2\u096a\u096b\7\31\2\2\u096b\u096e\7\u0093\2\2\u096c\u096f\7-\2"+
"\2\u096d\u096f\7,\2\2\u096e\u096c\3\2\2\2\u096e\u096d\3\2\2\2\u096e\u096f"+
"\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0971\5\u01a6\u00d4\2\u0971\u0972\7"+
"\u0094\2\2\u0972\u09f8\3\2\2\2\u0973\u0974\7\26\2\2\u0974\u0976\7\u0093"+
"\2\2\u0975\u0977\t\t\2\2\u0976\u0975\3\2\2\2\u0976\u0977\3\2\2\2\u0977"+
"\u0978\3\2\2\2\u0978\u0979\5\u01a6\u00d4\2\u0979\u097a\7\u0094\2\2\u097a"+
"\u09f8\3\2\2\2\u097b\u097c\7\27\2\2\u097c\u097e\7\u0093\2\2\u097d\u097f"+
"\t\t\2\2\u097e\u097d\3\2\2\2\u097e\u097f\3\2\2\2\u097f\u0980\3\2\2\2\u0980"+
"\u0981\5\u01a6\u00d4\2\u0981\u0982\7\u0094\2\2\u0982\u09f8\3\2\2\2\u0983"+
"\u0984\7\30\2\2\u0984\u0986\7\u0093\2\2\u0985\u0987\t\t\2\2\u0986\u0985"+
"\3\2\2\2\u0986\u0987\3\2\2\2\u0987\u0988\3\2\2\2\u0988\u0989\5\u01a6\u00d4"+
"\2\u0989\u098a\7\u0094\2\2\u098a\u09f8\3\2\2\2\u098b\u09f8\5\u015e\u00b0"+
"\2\u098c\u098d\7\25\2\2\u098d\u098e\7\u0093\2\2\u098e\u098f\5\u0130\u0099"+
"\2\u098f\u0990\7\u009a\2\2\u0990\u0995\5\u0130\u0099\2\u0991\u0992\7\u009a"+
"\2\2\u0992\u0994\5\u0130\u0099\2\u0993\u0991\3\2\2\2\u0994\u0997\3\2\2"+
"\2\u0995\u0993\3\2\2\2\u0995\u0996\3\2\2\2\u0996\u0998\3\2\2\2\u0997\u0995"+
"\3\2\2\2\u0998\u0999\7\u0094\2\2\u0999\u09f8\3\2\2\2\u099a\u099b\7D\2"+
"\2\u099b\u099c\7\u0093\2\2\u099c\u099f\5\u0130\u0099\2\u099d\u099e\7\u009a"+
"\2\2\u099e\u09a0\5\u0130\u0099\2\u099f\u099d\3\2\2\2\u099f\u09a0\3\2\2"+
"\2\u09a0\u09a1\3\2\2\2\u09a1\u09a2\7\u0094\2\2\u09a2\u09a3\5\u01d0\u00e9"+
"\2\u09a3\u09f8\3\2\2\2\u09a4\u09a5\7E\2\2\u09a5\u09a6\7\u0093\2\2\u09a6"+
"\u09a9\5\u0130\u0099\2\u09a7\u09a8\7\u009a\2\2\u09a8\u09aa\5\u0130\u0099"+
"\2\u09a9\u09a7\3\2\2\2\u09a9\u09aa\3\2\2\2\u09aa\u09ab\3\2\2\2\u09ab\u09ac"+
"\7\u0094\2\2\u09ac\u09ad\5\u01d0\u00e9\2\u09ad\u09f8\3\2\2\2\u09ae\u09af"+
"\7F\2\2\u09af\u09b0\7\u0093\2\2\u09b0\u09b1\5\u0130\u0099\2\u09b1\u09b2"+
"\7\u0094\2\2\u09b2\u09f8\3\2\2\2\u09b3\u09b4\7G\2\2\u09b4\u09b5\7\u0093"+
"\2\2\u09b5\u09b6\5\u0130\u0099\2\u09b6\u09b7\7\u0094\2\2\u09b7\u09b8\5"+
"\u01d0\u00e9\2\u09b8\u09f8\3\2\2\2\u09b9\u09ba\7H\2\2\u09ba\u09bb\7\u0093"+
"\2\2\u09bb\u09bc\5\u0130\u0099\2\u09bc\u09bd\7\u009a\2\2\u09bd\u09be\5"+
"\u01cc\u00e7\2\u09be\u09bf\7\u0094\2\2\u09bf\u09f8\3\2\2\2\u09c0\u09c1"+
"\7\u0089\2\2\u09c1\u09c2\7\u0093\2\2\u09c2\u09c3\5\u0130\u0099\2\u09c3"+
"\u09c4\7\u0094\2\2\u09c4\u09f8\3\2\2\2\u09c5\u09c6\7\u008a\2\2\u09c6\u09c7"+
"\7\u0093\2\2\u09c7\u09c8\5\u01b2\u00da\2\u09c8\u09c9\7\u0094\2\2\u09c9"+
"\u09f8\3\2\2\2\u09ca\u09cb\7L\2\2\u09cb\u09cc\7\u0093\2\2\u09cc\u09cd"+
"\5\u0130\u0099\2\u09cd\u09ce\7\u009a\2\2\u09ce\u09d3\5\u01a4\u00d3\2\u09cf"+
"\u09d0\7\u009a\2\2\u09d0\u09d2\5\u01a4\u00d3\2\u09d1\u09cf\3\2\2\2\u09d2"+
"\u09d5\3\2\2\2\u09d3\u09d1\3\2\2\2\u09d3\u09d4\3\2\2\2\u09d4\u09d6\3\2"+
"\2\2\u09d5\u09d3\3\2\2\2\u09d6\u09d7\7\u0094\2\2\u09d7\u09f8\3\2\2\2\u09d8"+
"\u09d9\7M\2\2\u09d9\u09da\7\u0093\2\2\u09da\u09db\5\u0130\u0099\2\u09db"+
"\u09dc\7\u0094\2\2\u09dc\u09f8\3\2\2\2\u09dd\u09de\7N\2\2\u09de\u09df"+
"\7\u0093\2\2\u09df\u09e0\5\u0130\u0099\2\u09e0\u09e1\t\n\2\2\u09e1\u09e4"+
"\5\u019e\u00d0\2\u09e2\u09e3\7\u009a\2\2\u09e3\u09e5\5\u01ae\u00d8\2\u09e4"+
"\u09e2\3\2\2\2\u09e4\u09e5\3\2\2\2\u09e5\u09e6\3\2\2\2\u09e6\u09e7\7\u0094"+
"\2\2\u09e7\u09e8\5\u01d0\u00e9\2\u09e8\u09f8\3\2\2\2\u09e9\u09ea\7I\2"+
"\2\u09ea\u09eb\7\u0093\2\2\u09eb\u09ec\5\u01cc\u00e7\2\u09ec\u09ed\7\u0094"+
"\2\2\u09ed\u09f8\3\2\2\2\u09ee\u09f1\7O\2\2\u09ef\u09f0\7\u0093\2\2\u09f0"+
"\u09f2\7\u0094\2\2\u09f1\u09ef\3\2\2\2\u09f1\u09f2\3\2\2\2\u09f2\u09f3"+
"\3\2\2\2\u09f3\u09f8\5\u01d0\u00e9\2\u09f4\u09f5\7;\2\2\u09f5\u09f6\7"+
"\u0093\2\2\u09f6\u09f8\7\u0094\2\2\u09f7\u095a\3\2\2\2\u09f7\u0962\3\2"+
"\2\2\u09f7\u096a\3\2\2\2\u09f7\u0973\3\2\2\2\u09f7\u097b\3\2\2\2\u09f7"+
"\u0983\3\2\2\2\u09f7\u098b\3\2\2\2\u09f7\u098c\3\2\2\2\u09f7\u099a\3\2"+
"\2\2\u09f7\u09a4\3\2\2\2\u09f7\u09ae\3\2\2\2\u09f7\u09b3\3\2\2\2\u09f7"+
"\u09b9\3\2\2\2\u09f7\u09c0\3\2\2\2\u09f7\u09c5\3\2\2\2\u09f7\u09ca\3\2"+
"\2\2\u09f7\u09d8\3\2\2\2\u09f7\u09dd\3\2\2\2\u09f7\u09e9\3\2\2\2\u09f7"+
"\u09ee\3\2\2\2\u09f7\u09f4\3\2\2\2\u09f8\u015d\3\2\2\2\u09f9\u09fd\7\62"+
"\2\2\u09fa\u09fd\7\63\2\2\u09fb\u09fd\7\4\2\2\u09fc\u09f9\3\2\2\2\u09fc"+
"\u09fa\3\2\2\2\u09fc\u09fb\3\2\2\2\u09fd\u09fe\3\2\2\2\u09fe\u0a00\7\u0093"+
"\2\2\u09ff\u0a01\5\u01a6\u00d4\2\u0a00\u09ff\3\2\2\2\u0a00\u0a01\3\2\2"+
"\2\u0a01\u0a02\3\2\2\2\u0a02\u0a03\7\u0094\2\2\u0a03\u0a04\5\u01d0\u00e9"+
"\2\u0a04\u015f\3\2\2\2\u0a05\u0a0b\5\u0162\u00b2\2\u0a06\u0a08\7\u0093"+
"\2\2\u0a07\u0a09\5\u0164\u00b3\2\u0a08\u0a07\3\2\2\2\u0a08\u0a09\3\2\2"+
"\2\u0a09\u0a0a\3\2\2\2\u0a0a\u0a0c\7\u0094\2\2\u0a0b\u0a06\3\2\2\2\u0a0b"+
"\u0a0c\3\2\2\2\u0a0c\u0161\3\2\2\2\u0a0d\u0a18\5\u01e2\u00f2\2\u0a0e\u0a18"+
"\7\63\2\2\u0a0f\u0a18\7\62\2\2\u0a10\u0a18\7\4\2\2\u0a11\u0a18\7\23\2"+
"\2\u0a12\u0a18\7\24\2\2\u0a13\u0a18\7\17\2\2\u0a14\u0a18\7R\2\2\u0a15"+
"\u0a18\7y\2\2\u0a16\u0a18\7\6\2\2\u0a17\u0a0d\3\2\2\2\u0a17\u0a0e\3\2"+
"\2\2\u0a17\u0a0f\3\2\2\2\u0a17\u0a10\3\2\2\2\u0a17\u0a11\3\2\2\2\u0a17"+
"\u0a12\3\2\2\2\u0a17\u0a13\3\2\2\2\u0a17\u0a14\3\2\2\2\u0a17\u0a15\3\2"+
"\2\2\u0a17\u0a16\3\2\2\2\u0a18\u0163\3\2\2\2\u0a19\u0a1b\t\t\2\2\u0a1a"+
"\u0a19\3\2\2\2\u0a1a\u0a1b\3\2\2\2\u0a1b\u0a1c\3\2\2\2\u0a1c\u0a21\5\u0166"+
"\u00b4\2\u0a1d\u0a1e\7\u009a\2\2\u0a1e\u0a20\5\u0166\u00b4\2\u0a1f\u0a1d"+
"\3\2\2\2\u0a20\u0a23\3\2\2\2\u0a21\u0a1f\3\2\2\2\u0a21\u0a22\3\2\2\2\u0a22"+
"\u0165\3\2\2\2\u0a23\u0a21\3\2\2\2\u0a24\u0a26\5\20\t\2\u0a25\u0a24\3"+
"\2\2\2\u0a25\u0a26\3\2\2\2\u0a26\u0a27\3\2\2\2\u0a27\u0a28\5\u01aa\u00d6"+
"\2\u0a28\u0167\3\2\2\2\u0a29\u0a2a\5\u0142\u00a2\2\u0a2a\u0a2b\7\13\2"+
"\2\u0a2b\u0a2c\5\u0142\u00a2\2\u0a2c\u0169\3\2\2\2\u0a2d\u0a2e\5\u016c"+
"\u00b7\2\u0a2e\u016b\3\2\2\2\u0a2f\u0a33\5\u0170\u00b9\2\u0a30\u0a32\5"+
"\u016e\u00b8\2\u0a31\u0a30\3\2\2\2\u0a32\u0a35\3\2\2\2\u0a33\u0a31\3\2"+
"\2\2\u0a33\u0a34\3\2\2\2\u0a34\u016d\3\2\2\2\u0a35\u0a33\3\2\2\2\u0a36"+
"\u0a3d\7\u008e\2\2\u0a37\u0a38\7\u008d\2\2\u0a38\u0a39\5\u0130\u0099\2"+
"\u0a39\u0a3a\7\u0096\2\2\u0a3a\u0a3b\7\u00ac\2\2\u0a3b\u0a3d\3\2\2\2\u0a3c"+
"\u0a36\3\2\2\2\u0a3c\u0a37\3\2\2\2\u0a3d\u0a3e\3\2\2\2\u0a3e\u0a3f\5\u0170"+
"\u00b9\2\u0a3f\u016f\3\2\2\2\u0a40\u0a45\5\u0172\u00ba\2\u0a41\u0a42\7"+
"\n\2\2\u0a42\u0a44\5\u0172\u00ba\2\u0a43\u0a41\3\2\2\2\u0a44\u0a47\3\2"+
"\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46\3\2\2\2\u0a46\u0171\3\2\2\2\u0a47"+
"\u0a45\3\2\2\2\u0a48\u0a4d\5\u0174\u00bb\2\u0a49\u0a4a\7\13\2\2\u0a4a"+
"\u0a4c\5\u0174\u00bb\2\u0a4b\u0a49\3\2\2\2\u0a4c\u0a4f\3\2\2\2\u0a4d\u0a4b"+
"\3\2\2\2\u0a4d\u0a4e\3\2\2\2\u0a4e\u0173\3\2\2\2\u0a4f\u0a4d\3\2\2\2\u0a50"+
"\u0a52\5\u0186\u00c4\2\u0a51\u0a50\3\2\2\2\u0a51\u0a52\3\2\2\2\u0a52\u0a53"+
"\3\2\2\2\u0a53\u0a56\5\u0176\u00bc\2\u0a54\u0a55\7U\2\2\u0a55\u0a57\5"+
"\u0176\u00bc\2\u0a56\u0a54\3\2\2\2\u0a56\u0a57\3\2\2\2\u0a57\u0175\3\2"+
"\2\2\u0a58\u0a5d\7\r\2\2\u0a59\u0a5d\7\f\2\2\u0a5a\u0a5b\7\16\2\2\u0a5b"+
"\u0a5d\5\u017a\u00be\2\u0a5c\u0a58\3\2\2\2\u0a5c\u0a59\3\2\2\2\u0a5c\u0a5a"+
"\3\2\2\2\u0a5d\u0a5f\3\2\2\2\u0a5e\u0a60\5\u0186\u00c4\2\u0a5f\u0a5e\3"+
"\2\2\2\u0a5f\u0a60\3\2\2\2\u0a60\u0a62\3\2\2\2\u0a61\u0a5c\3\2\2\2\u0a61"+
"\u0a62\3\2\2\2\u0a62\u0a63\3\2\2\2\u0a63\u0a64\5\u0178\u00bd\2\u0a64\u0177"+
"\3\2\2\2\u0a65\u0a6b\5\u017e\u00c0\2\u0a66\u0a67\7\u0093\2\2\u0a67\u0a68"+
"\5\u016a\u00b6\2\u0a68\u0a69\7\u0094\2\2\u0a69\u0a6b\3\2\2\2\u0a6a\u0a65"+
"\3\2\2\2\u0a6a\u0a66\3\2\2\2\u0a6b\u0a70\3\2\2\2\u0a6c\u0a6d\7\17\2\2"+
"\u0a6d\u0a71\5\u0182\u00c2\2\u0a6e\u0a6f\7{\2\2\u0a6f\u0a71\5\u0184\u00c3"+
"\2\u0a70\u0a6c\3\2\2\2\u0a70\u0a6e\3\2\2\2\u0a70\u0a71\3\2\2\2\u0a71\u0179"+
"\3\2\2\2\u0a72\u0a73\7\u0093\2\2\u0a73\u0a78\5\u017c\u00bf\2\u0a74\u0a75"+
"\7\u009a\2\2\u0a75\u0a77\5\u017c\u00bf\2\u0a76\u0a74\3\2\2\2\u0a77\u0a7a"+
"\3\2\2\2\u0a78\u0a76\3\2\2\2\u0a78\u0a79\3\2\2\2\u0a79\u0a7b\3\2\2\2\u0a7a"+
"\u0a78\3\2\2\2\u0a7b\u0a7c\7\u0094\2\2\u0a7c\u017b\3\2\2\2\u0a7d\u0a7e"+
"\5\u01b6\u00dc\2\u0a7e\u017d\3\2\2\2\u0a7f\u0a82\5\u0180\u00c1\2\u0a80"+
"\u0a82\5\u0198\u00cd\2\u0a81\u0a7f\3\2\2\2\u0a81\u0a80\3\2\2\2\u0a82\u017f"+
"\3\2\2\2\u0a83\u0a84\7\u00c7\2\2\u0a84\u0a87\7\u0099\2\2\u0a85\u0a88\7"+
"\u00c7\2\2\u0a86\u0a88\7V\2\2\u0a87\u0a85\3\2\2\2\u0a87\u0a86\3\2\2\2"+
"\u0a88\u0a89\3\2\2\2\u0a89\u0a8b\7\u0093\2\2\u0a8a\u0a8c\5\u01a8\u00d5"+
"\2\u0a8b\u0a8a\3\2\2\2\u0a8b\u0a8c\3\2\2\2\u0a8c\u0a8d\3\2\2\2\u0a8d\u0a8e"+
"\7\u0094\2\2\u0a8e\u0181\3\2\2\2\u0a8f\u0a90\7\u00c7\2\2\u0a90\u0a91\7"+
"\u0099\2\2\u0a91\u0a92\7\u00c7\2\2\u0a92\u0a94\7\u0093\2\2\u0a93\u0a95"+
"\5\u01b4\u00db\2\u0a94\u0a93\3\2\2\2\u0a94\u0a95\3\2\2\2\u0a95\u0a96\3"+
"\2\2\2\u0a96\u0a97\7\u0094\2\2\u0a97\u0183\3\2\2\2\u0a98\u0a99\7\u0093"+
"\2\2\u0a99\u0a9a\5\u0130\u0099\2\u0a9a\u0a9b\7\u0094\2\2\u0a9b\u0185\3"+
"\2\2\2\u0a9c\u0aa6\7\u0095\2\2\u0a9d\u0aa2\5\u0130\u0099\2\u0a9e\u0aa0"+
"\7\u0099\2\2\u0a9f\u0aa1\5\u0130\u0099\2\u0aa0\u0a9f\3\2\2\2\u0aa0\u0aa1"+
"\3\2\2\2\u0aa1\u0aa3\3\2\2\2\u0aa2\u0a9e\3\2\2\2\u0aa2\u0aa3\3\2\2\2\u0aa3"+
"\u0aa7\3\2\2\2\u0aa4\u0aa5\7\u0099\2\2\u0aa5\u0aa7\5\u0130\u0099\2\u0aa6"+
"\u0a9d\3\2\2\2\u0aa6\u0aa4\3\2\2\2\u0aa7\u0aa8\3\2\2\2\u0aa8\u0aa9\7\u0096"+
"\2\2\u0aa9\u0187\3\2\2\2\u0aaa\u0aab\7\u00c7\2\2\u0aab\u0aad\7\u0090\2"+
"\2\u0aac\u0aaa\3\2\2\2\u0aac\u0aad\3\2\2\2\u0aad\u0aae\3\2\2\2\u0aae\u0ab4"+
"\5\u01a4\u00d3\2\u0aaf\u0ab1\7\u0093\2\2\u0ab0\u0ab2\5\u01b2\u00da\2\u0ab1"+
"\u0ab0\3\2\2\2\u0ab1\u0ab2\3\2\2\2\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\7\u0094"+
"\2\2\u0ab4\u0aaf\3\2\2\2\u0ab4\u0ab5\3\2\2\2\u0ab5\u0ab7\3\2\2\2\u0ab6"+
"\u0ab8\5\u018a\u00c6\2\u0ab7\u0ab6\3\2\2\2\u0ab7\u0ab8\3\2\2\2\u0ab8\u0189"+
"\3\2\2\2\u0ab9\u0abd\5\u018c\u00c7\2\u0aba\u0abc\5\u018c\u00c7\2\u0abb"+
"\u0aba\3\2\2\2\u0abc\u0abf\3\2\2\2\u0abd\u0abb\3\2\2\2\u0abd\u0abe\3\2"+
"\2\2\u0abe\u018b\3\2\2\2\u0abf\u0abd\3\2\2\2\u0ac0\u0ac2\7\u0095\2\2\u0ac1"+
"\u0ac3\5\u018e\u00c8\2\u0ac2\u0ac1\3\2\2\2\u0ac2\u0ac3\3\2\2\2\u0ac3\u0ac4"+
"\3\2\2\2\u0ac4\u0ac6\5\u0130\u0099\2\u0ac5\u0ac7\5\u0196\u00cc\2\u0ac6"+
"\u0ac5\3\2\2\2\u0ac6\u0ac7\3\2\2\2\u0ac7\u0aca\3\2\2\2\u0ac8\u0ac9\7\20"+
"\2\2\u0ac9\u0acb\7\u00c7\2\2\u0aca\u0ac8\3\2\2\2\u0aca\u0acb\3\2\2\2\u0acb"+
"\u0ace\3\2\2\2\u0acc\u0acd\7\17\2\2\u0acd\u0acf\5\u0130\u0099\2\u0ace"+
"\u0acc\3\2\2\2\u0ace\u0acf\3\2\2\2\u0acf\u0ad0\3\2\2\2\u0ad0\u0ad1\7\u0096"+
"\2\2\u0ad1\u018d\3\2\2\2\u0ad2\u0ad3\7\32\2\2\u0ad3\u0ad4\5\u0190\u00c9"+
"\2\u0ad4\u0ad5\7 \2\2\u0ad5\u018f\3\2\2\2\u0ad6\u0adb\5\u0192\u00ca\2"+
"\u0ad7\u0ad8\7\u009a\2\2\u0ad8\u0ada\5\u0192\u00ca\2\u0ad9\u0ad7\3\2\2"+
"\2\u0ada\u0add\3\2\2\2\u0adb\u0ad9\3\2\2\2\u0adb\u0adc\3\2\2\2\u0adc\u0191"+
"\3\2\2\2\u0add\u0adb\3\2\2\2\u0ade\u0ae6\7\u00a7\2\2\u0adf\u0ae6\5\u0194"+
"\u00cb\2\u0ae0\u0ae3\5\u0130\u0099\2\u0ae1\u0ae2\7\20\2\2\u0ae2\u0ae4"+
"\5\u01de\u00f0\2\u0ae3\u0ae1\3\2\2\2\u0ae3\u0ae4\3\2\2\2\u0ae4\u0ae6\3"+
"\2\2\2\u0ae5\u0ade\3\2\2\2\u0ae5\u0adf\3\2\2\2\u0ae5\u0ae0\3\2\2\2\u0ae6"+
"\u0193\3\2\2\2\u0ae7\u0ae8\7\u00c7\2\2\u0ae8\u0ae9\7\u00b8\2\2\u0ae9\u0aec"+
"\7\u00a7\2\2\u0aea\u0aeb\7\20\2\2\u0aeb\u0aed\7\u00c7\2\2\u0aec\u0aea"+
"\3\2\2\2\u0aec\u0aed\3\2\2\2\u0aed\u0195\3\2\2\2\u0aee\u0aef\7\u00be\2"+
"\2\u0aef\u0af0\7\u00c7\2\2\u0af0\u0af1\7\u0093\2\2\u0af1\u0af2\7\u00c7"+
"\2\2\u0af2\u0af3\7\u0094\2\2\u0af3\u0197\3\2\2\2\u0af4\u0af5\7\u00c7\2"+
"\2\u0af5\u0af7\7\u0090\2\2\u0af6\u0af4\3\2\2\2\u0af6\u0af7\3\2\2\2\u0af7"+
"\u0af8\3\2\2\2\u0af8\u0afe\5\u01a4\u00d3\2\u0af9\u0afb\7\u0093\2\2\u0afa"+
"\u0afc\5\u01b2\u00da\2\u0afb\u0afa\3\2\2\2\u0afb\u0afc\3\2\2\2\u0afc\u0afd"+
"\3\2\2\2\u0afd\u0aff\7\u0094\2\2\u0afe\u0af9\3\2\2\2\u0afe\u0aff\3\2\2"+
"\2\u0aff\u0b01\3\2\2\2\u0b00\u0b02\5\u018a\u00c6\2\u0b01\u0b00\3\2\2\2"+
"\u0b01\u0b02\3\2\2\2\u0b02\u0b04\3\2\2\2\u0b03\u0b05\5\u019a\u00ce\2\u0b04"+
"\u0b03\3\2\2\2\u0b04\u0b05\3\2\2\2\u0b05\u0199\3\2\2\2\u0b06\u0b07\7\u00be"+
"\2\2\u0b07\u0b0c\7\u00c7\2\2\u0b08\u0b09\7\u0093\2\2\u0b09\u0b0a\5\u01f8"+
"\u00fd\2\u0b0a\u0b0b\7\u0094\2\2\u0b0b\u0b0d\3\2\2\2\u0b0c\u0b08\3\2\2"+
"\2\u0b0c\u0b0d\3\2\2\2\u0b0d\u019b\3\2\2\2\u0b0e\u0b10\5\u01a4\u00d3\2"+
"\u0b0f\u0b11\5\u01a0\u00d1\2\u0b10\u0b0f\3\2\2\2\u0b10\u0b11\3\2\2\2\u0b11"+
"\u019d\3\2\2\2\u0b12\u0b14\5\u01a4\u00d3\2\u0b13\u0b15\5\u01a0\u00d1\2"+
"\u0b14\u0b13\3\2\2\2\u0b14\u0b15\3\2\2\2\u0b15\u0b19\3\2\2\2\u0b16\u0b18"+
"\5\u01a2\u00d2\2\u0b17\u0b16\3\2\2\2\u0b18\u0b1b\3\2\2\2\u0b19\u0b17\3"+
"\2\2\2\u0b19\u0b1a\3\2\2\2\u0b1a\u019f\3\2\2\2\u0b1b\u0b19\3\2\2\2\u0b1c"+
"\u0b1d\7\u00ae\2\2\u0b1d\u0b22\5\u019e\u00d0\2\u0b1e\u0b1f\7\u009a\2\2"+
"\u0b1f\u0b21\5\u019e\u00d0\2\u0b20\u0b1e\3\2\2\2\u0b21\u0b24\3\2\2\2\u0b22"+
"\u0b20\3\2\2\2\u0b22\u0b23\3\2\2\2\u0b23\u0b25\3\2\2\2\u0b24\u0b22\3\2"+
"\2\2\u0b25\u0b26\7\u00ac\2\2\u0b26\u01a1\3\2\2\2\u0b27\u0b29\7\u0095\2"+
"\2\u0b28\u0b2a\7\u00c7\2\2\u0b29\u0b28\3\2\2\2\u0b29\u0b2a\3\2\2\2\u0b2a"+
"\u0b2b\3\2\2\2\u0b2b\u0b2c\7\u0096\2\2\u0b2c\u01a3\3\2\2\2\u0b2d\u0b32"+
"\5\u01e0\u00f1\2\u0b2e\u0b2f\7\u00b8\2\2\u0b2f\u0b31\5\u01e0\u00f1\2\u0b30"+
"\u0b2e\3\2\2\2\u0b31\u0b34\3\2\2\2\u0b32\u0b30\3\2\2\2\u0b32\u0b33\3\2"+
"\2\2\u0b33\u01a5\3\2\2\2\u0b34\u0b32\3\2\2\2\u0b35\u0b3a\5\u01aa\u00d6"+
"\2\u0b36\u0b37\7\u009a\2\2\u0b37\u0b39\5\u01aa\u00d6\2\u0b38\u0b36\3\2"+
"\2\2\u0b39\u0b3c\3\2\2\2\u0b3a\u0b38\3\2\2\2\u0b3a\u0b3b\3\2\2\2\u0b3b"+
"\u01a7\3\2\2\2\u0b3c\u0b3a\3\2\2\2\u0b3d\u0b42\5\u01ac\u00d7\2\u0b3e\u0b3f"+
"\7\u009a\2\2\u0b3f\u0b41\5\u01ac\u00d7\2\u0b40\u0b3e\3\2\2\2\u0b41\u0b44"+
"\3\2\2\2\u0b42\u0b40\3\2\2\2\u0b42\u0b43\3\2\2\2\u0b43\u01a9\3\2\2\2\u0b44"+
"\u0b42\3\2\2\2\u0b45\u0b48\5\u01ae\u00d8\2\u0b46\u0b48\5\u01b6\u00dc\2"+
"\u0b47\u0b45\3\2\2\2\u0b47\u0b46\3\2\2\2\u0b48\u01ab\3\2\2\2\u0b49\u0b4c"+
"\5\u01b0\u00d9\2\u0b4a\u0b4c\5\u01b8\u00dd\2\u0b4b\u0b49\3\2\2\2\u0b4b"+
"\u0b4a\3\2\2\2\u0b4c\u01ad\3\2\2\2\u0b4d\u0b4e\7\u00c7\2\2\u0b4e\u0b55"+
"\7\u0099\2\2\u0b4f\u0b56\5\u0130\u0099\2\u0b50\u0b52\7\u0093\2\2\u0b51"+
"\u0b53\5\u01b2\u00da\2\u0b52\u0b51\3\2\2\2\u0b52\u0b53\3\2\2\2\u0b53\u0b54"+
"\3\2\2\2\u0b54\u0b56\7\u0094\2\2\u0b55\u0b4f\3\2\2\2\u0b55\u0b50\3\2\2"+
"\2\u0b56\u01af\3\2\2\2\u0b57\u0b58\7\u00c7\2\2\u0b58\u0b5f\7\u0099\2\2"+
"\u0b59\u0b60\5\u01b6\u00dc\2\u0b5a\u0b5c\7\u0093\2\2\u0b5b\u0b5d\5\u01b4"+
"\u00db\2\u0b5c\u0b5b\3\2\2\2\u0b5c\u0b5d\3\2\2\2\u0b5d\u0b5e\3\2\2\2\u0b5e"+
"\u0b60\7\u0094\2\2\u0b5f\u0b59\3\2\2\2\u0b5f\u0b5a\3\2\2\2\u0b60\u01b1"+
"\3\2\2\2\u0b61\u0b66\5\u0130\u0099\2\u0b62\u0b63\7\u009a\2\2\u0b63\u0b65"+
"\5\u0130\u0099\2\u0b64\u0b62\3\2\2\2\u0b65\u0b68\3\2\2\2\u0b66\u0b64\3"+
"\2\2\2\u0b66\u0b67\3\2\2\2\u0b67\u01b3\3\2\2\2\u0b68\u0b66\3\2\2\2\u0b69"+
"\u0b6e\5\u01b8\u00dd\2\u0b6a\u0b6b\7\u009a\2\2\u0b6b\u0b6d\5\u01b8\u00dd"+
"\2\u0b6c\u0b6a\3\2\2\2\u0b6d\u0b70\3\2\2\2\u0b6e\u0b6c\3\2\2\2\u0b6e\u0b6f"+
"\3\2\2\2\u0b6f\u01b5\3\2\2\2\u0b70\u0b6e\3\2\2\2\u0b71\u0b7c\5\u01bc\u00df"+
"\2\u0b72\u0b7c\5\u01e4\u00f3\2\u0b73\u0b7c\5\u01ba\u00de\2\u0b74\u0b7c"+
"\5\u01c2\u00e2\2\u0b75\u0b7c\5\u01c0\u00e1\2\u0b76\u0b7c\5\u01c4\u00e3"+
"\2\u0b77\u0b7c\5\u01c6\u00e4\2\u0b78\u0b7c\5\u01c8\u00e5\2\u0b79\u0b7c"+
"\7\u00a7\2\2\u0b7a\u0b7c\5\u0194\u00cb\2\u0b7b\u0b71\3\2\2\2\u0b7b\u0b72"+
"\3\2\2\2\u0b7b\u0b73\3\2\2\2\u0b7b\u0b74\3\2\2\2\u0b7b\u0b75\3\2\2\2\u0b7b"+
"\u0b76\3\2\2\2\u0b7b\u0b77\3\2\2\2\u0b7b\u0b78\3\2\2\2\u0b7b\u0b79\3\2"+
"\2\2\u0b7b\u0b7a\3\2\2\2\u0b7c\u01b7\3\2\2\2\u0b7d\u0b80\5\u01be\u00e0"+
"\2\u0b7e\u0b80\5\u01b6\u00dc\2\u0b7f\u0b7d\3\2\2\2\u0b7f\u0b7e\3\2\2\2"+
"\u0b80\u01b9\3\2\2\2\u0b81\u0b87\5\u0130\u0099\2\u0b82\u0b88\78\2\2\u0b83"+
"\u0b88\79\2\2\u0b84\u0b88\7f\2\2\u0b85\u0b88\7e\2\2\u0b86\u0b88\7d\2\2"+
"\u0b87\u0b82\3\2\2\2\u0b87\u0b83\3\2\2\2\u0b87\u0b84\3\2\2\2\u0b87\u0b85"+
"\3\2\2\2\u0b87\u0b86\3\2\2\2\u0b87\u0b88\3\2\2\2\u0b88\u01bb\3\2\2\2\u0b89"+
"\u0b8a\7K\2\2\u0b8a\u01bd\3\2\2\2\u0b8b\u0b8c\7\63\2\2\u0b8c\u01bf\3\2"+
"\2\2\u0b8d\u0b8e\7\u00a7\2\2\u0b8e\u0b92\7\u009f\2\2\u0b8f\u0b93\5\u01f8"+
"\u00fd\2\u0b90\u0b93\7\u00c7\2\2\u0b91\u0b93\5\u01fa\u00fe\2\u0b92\u0b8f"+
"\3\2\2\2\u0b92\u0b90\3\2\2\2\u0b92\u0b91\3\2\2\2\u0b93\u01c1\3\2\2\2\u0b94"+
"\u0b98\5\u01f8\u00fd\2\u0b95\u0b98\7\u00c7\2\2\u0b96\u0b98\5\u01fa\u00fe"+
"\2\u0b97\u0b94\3\2\2\2\u0b97\u0b95\3\2\2\2\u0b97\u0b96\3\2\2\2\u0b98\u0b99"+
"\3\2\2\2\u0b99\u0b9d\7\u0099\2\2\u0b9a\u0b9e\5\u01f8\u00fd\2\u0b9b\u0b9e"+
"\7\u00c7\2\2\u0b9c\u0b9e\5\u01fa\u00fe\2\u0b9d\u0b9a\3\2\2\2\u0b9d\u0b9b"+
"\3\2\2\2\u0b9d\u0b9c\3\2\2\2\u0b9e\u01c3\3\2\2\2\u0b9f\u0ba3\5\u01f8\u00fd"+
"\2\u0ba0\u0ba3\7\u00c7\2\2\u0ba1\u0ba3\5\u01fa\u00fe\2\u0ba2\u0b9f\3\2"+
"\2\2\u0ba2\u0ba0\3\2\2\2\u0ba2\u0ba1\3\2\2\2\u0ba3\u0ba4\3\2\2\2\u0ba4"+
"\u0ba5\7\63\2\2\u0ba5\u01c5\3\2\2\2\u0ba6\u0baa\5\u01f8\u00fd\2\u0ba7"+
"\u0baa\7\u00c7\2\2\u0ba8\u0baa\5\u01fa\u00fe\2\u0ba9\u0ba6\3\2\2\2\u0ba9"+
"\u0ba7\3\2\2\2\u0ba9\u0ba8\3\2\2\2\u0baa\u0bab\3\2\2\2\u0bab\u0bac\7J"+
"\2\2\u0bac\u01c7\3\2\2\2\u0bad\u0bae\7\u0095\2\2\u0bae\u0bb3\5\u01ca\u00e6"+
"\2\u0baf\u0bb0\7\u009a\2\2\u0bb0\u0bb2\5\u01ca\u00e6\2\u0bb1\u0baf\3\2"+
"\2\2\u0bb2\u0bb5\3\2\2\2\u0bb3\u0bb1\3\2\2\2\u0bb3\u0bb4\3\2\2\2\u0bb4"+
"\u0bb6\3\2\2\2\u0bb5\u0bb3\3\2\2\2\u0bb6\u0bb7\7\u0096\2\2\u0bb7\u01c9"+
"\3\2\2\2\u0bb8\u0bbc\5\u01c2\u00e2\2\u0bb9\u0bbc\5\u01c0\u00e1\2\u0bba"+
"\u0bbc\5\u0200\u0101\2\u0bbb\u0bb8\3\2\2\2\u0bbb\u0bb9\3\2\2\2\u0bbb\u0bba"+
"\3\2\2\2\u0bbc\u01cb\3\2\2\2\u0bbd\u0bbe\5\u01ce\u00e8\2\u0bbe\u0bbf\5"+
"\u01d0\u00e9\2\u0bbf\u01cd\3\2\2\2\u0bc0\u0bc2\5\u01d8\u00ed\2\u0bc1\u0bc3"+
"\7\u0092\2\2\u0bc2\u0bc1\3\2\2\2\u0bc2\u0bc3\3\2\2\2\u0bc3\u01cf\3\2\2"+
"\2\u0bc4\u0bc6\5\u01d2\u00ea\2\u0bc5\u0bc4\3\2\2\2\u0bc6\u0bc9\3\2\2\2"+
"\u0bc7\u0bc5\3\2\2\2\u0bc7\u0bc8\3\2\2\2\u0bc8\u01d1\3\2\2\2\u0bc9\u0bc7"+
"\3\2\2\2\u0bca\u0bcc\5\u01d4\u00eb\2\u0bcb\u0bcd\7\u0092\2\2\u0bcc\u0bcb"+
"\3\2\2\2\u0bcc\u0bcd\3\2\2\2\u0bcd\u01d3\3\2\2\2\u0bce\u0bd2\5\u01d6\u00ec"+
"\2\u0bcf\u0bd0\7\u00b8\2\2\u0bd0\u0bd2\5\u01d8\u00ed\2\u0bd1\u0bce\3\2"+
"\2\2\u0bd1\u0bcf\3\2\2\2\u0bd2\u01d5\3\2\2\2\u0bd3\u0bd4\7\u0095\2\2\u0bd4"+
"\u0bd9\5\u0130\u0099\2\u0bd5\u0bd6\7\u009a\2\2\u0bd6\u0bd8\5\u0130\u0099"+
"\2\u0bd7\u0bd5\3\2\2\2\u0bd8\u0bdb\3\2\2\2\u0bd9\u0bd7\3\2\2\2\u0bd9\u0bda"+
"\3\2\2\2\u0bda\u0bdc\3\2\2\2\u0bdb\u0bd9\3\2\2\2\u0bdc\u0bdd\7\u0096\2"+
"\2\u0bdd\u01d7\3\2\2\2\u0bde\u0be4\5\u01da\u00ee\2\u0bdf\u0be1\7\u0093"+
"\2\2\u0be0\u0be2\5\u0164\u00b3\2\u0be1\u0be0\3\2\2\2\u0be1\u0be2\3\2\2"+
"\2\u0be2\u0be3\3\2\2\2\u0be3\u0be5\7\u0094\2\2\u0be4\u0bdf\3\2\2\2\u0be4"+
"\u0be5\3\2\2\2\u0be5\u01d9\3\2\2\2\u0be6\u0bee\5\u01de\u00f0\2\u0be7\u0be8"+
"\7\u00bc\2\2\u0be8\u0bea\7\u00b8\2\2\u0be9\u0beb\5\u01de\u00f0\2\u0bea"+
"\u0be9\3\2\2\2\u0bea\u0beb\3\2\2\2\u0beb\u0bed\3\2\2\2\u0bec\u0be7\3\2"+
"\2\2\u0bed\u0bf0\3\2\2\2\u0bee\u0bec\3\2\2\2\u0bee\u0bef\3\2\2\2\u0bef"+
"\u01db\3\2\2\2\u0bf0\u0bee\3\2\2\2\u0bf1\u0bf4\7\u00c7\2\2\u0bf2\u0bf4"+
"\7\u00c3\2\2\u0bf3\u0bf1\3\2\2\2\u0bf3\u0bf2\3\2\2\2\u0bf4\u01dd\3\2\2"+
"\2\u0bf5\u0c2e\7\u00c7\2\2\u0bf6\u0c2e\7\u00c3\2\2\u0bf7\u0c2e\7y\2\2"+
"\u0bf8\u0c2e\7V\2\2\u0bf9\u0c2e\7\22\2\2\u0bfa\u0c2e\7\30\2\2\u0bfb\u0c2e"+
"\7\6\2\2\u0bfc\u0c2e\7N\2\2\u0bfd\u0c2e\7\25\2\2\u0bfe\u0c2e\7\u0083\2"+
"\2\u0bff\u0c2e\7\31\2\2\u0c00\u0c2e\7v\2\2\u0c01\u0c2e\7\t\2\2\u0c02\u0c2e"+
"\7\61\2\2\u0c03\u0c2e\7\r\2\2\u0c04\u0c2e\7\62\2\2\u0c05\u0c2e\7&\2\2"+
"\u0c06\u0c2e\7z\2\2\u0c07\u0c2e\7W\2\2\u0c08\u0c2e\7L\2\2\u0c09\u0c2e"+
"\7#\2\2\u0c0a\u0c2e\7\63\2\2\u0c0b\u0c2e\7$\2\2\u0c0c\u0c2e\7K\2\2\u0c0d"+
"\u0c2e\7\23\2\2\u0c0e\u0c2e\7~\2\2\u0c0f\u0c2e\7x\2\2\u0c10\u0c2e\7\26"+
"\2\2\u0c11\u0c2e\7}\2\2\u0c12\u0c2e\7C\2\2\u0c13\u0c2e\7\24\2\2\u0c14"+
"\u0c2e\7!\2\2\u0c15\u0c2e\7w\2\2\u0c16\u0c2e\7A\2\2\u0c17\u0c2e\7D\2\2"+
"\u0c18\u0c2e\7E\2\2\u0c19\u0c2e\7H\2\2\u0c1a\u0c2e\7?\2\2\u0c1b\u0c2e"+
"\7@\2\2\u0c1c\u0c2e\7%\2\2\u0c1d\u0c2e\7=\2\2\u0c1e\u0c2e\7R\2\2\u0c1f"+
"\u0c2e\7Q\2\2\u0c20\u0c2e\7\27\2\2\u0c21\u0c2e\7\21\2\2\u0c22\u0c2e\7"+
"B\2\2\u0c23\u0c2e\7T\2\2\u0c24\u0c2e\7M\2\2\u0c25\u0c2e\7>\2\2\u0c26\u0c2e"+
"\7U\2\2\u0c27\u0c2e\7|\2\2\u0c28\u0c2e\7S\2\2\u0c29\u0c2e\7J\2\2\u0c2a"+
"\u0c2e\7\17\2\2\u0c2b\u0c2e\7{\2\2\u0c2c\u0c2e\7\4\2\2\u0c2d\u0bf5\3\2"+
"\2\2\u0c2d\u0bf6\3\2\2\2\u0c2d\u0bf7\3\2\2\2\u0c2d\u0bf8\3\2\2\2\u0c2d"+
"\u0bf9\3\2\2\2\u0c2d\u0bfa\3\2\2\2\u0c2d\u0bfb\3\2\2\2\u0c2d\u0bfc\3\2"+
"\2\2\u0c2d\u0bfd\3\2\2\2\u0c2d\u0bfe\3\2\2\2\u0c2d\u0bff\3\2\2\2\u0c2d"+
"\u0c00\3\2\2\2\u0c2d\u0c01\3\2\2\2\u0c2d\u0c02\3\2\2\2\u0c2d\u0c03\3\2"+
"\2\2\u0c2d\u0c04\3\2\2\2\u0c2d\u0c05\3\2\2\2\u0c2d\u0c06\3\2\2\2\u0c2d"+
"\u0c07\3\2\2\2\u0c2d\u0c08\3\2\2\2\u0c2d\u0c09\3\2\2\2\u0c2d\u0c0a\3\2"+
"\2\2\u0c2d\u0c0b\3\2\2\2\u0c2d\u0c0c\3\2\2\2\u0c2d\u0c0d\3\2\2\2\u0c2d"+
"\u0c0e\3\2\2\2\u0c2d\u0c0f\3\2\2\2\u0c2d\u0c10\3\2\2\2\u0c2d\u0c11\3\2"+
"\2\2\u0c2d\u0c12\3\2\2\2\u0c2d\u0c13\3\2\2\2\u0c2d\u0c14\3\2\2\2\u0c2d"+
"\u0c15\3\2\2\2\u0c2d\u0c16\3\2\2\2\u0c2d\u0c17\3\2\2\2\u0c2d\u0c18\3\2"+
"\2\2\u0c2d\u0c19\3\2\2\2\u0c2d\u0c1a\3\2\2\2\u0c2d\u0c1b\3\2\2\2\u0c2d"+
"\u0c1c\3\2\2\2\u0c2d\u0c1d\3\2\2\2\u0c2d\u0c1e\3\2\2\2\u0c2d\u0c1f\3\2"+
"\2\2\u0c2d\u0c20\3\2\2\2\u0c2d\u0c21\3\2\2\2\u0c2d\u0c22\3\2\2\2\u0c2d"+
"\u0c23\3\2\2\2\u0c2d\u0c24\3\2\2\2\u0c2d\u0c25\3\2\2\2\u0c2d\u0c26\3\2"+
"\2\2\u0c2d\u0c27\3\2\2\2\u0c2d\u0c28\3\2\2\2\u0c2d\u0c29\3\2\2\2\u0c2d"+
"\u0c2a\3\2\2\2\u0c2d\u0c2b\3\2\2\2\u0c2d\u0c2c\3\2\2\2\u0c2e\u01df\3\2"+
"\2\2\u0c2f\u0c33\7\u00c7\2\2\u0c30\u0c33\7\61\2\2\u0c31\u0c33\7\u00c3"+
"\2\2\u0c32\u0c2f\3\2\2\2\u0c32\u0c30\3\2\2\2\u0c32\u0c31\3\2\2\2\u0c33"+
"\u01e1\3\2\2\2\u0c34\u0c37\7\u00c7\2\2\u0c35\u0c37\7\u00c3\2\2\u0c36\u0c34"+
"\3\2\2\2\u0c36\u0c35\3\2\2\2\u0c37\u01e3\3\2\2\2\u0c38\u0c3a\5\u01e6\u00f4"+
"\2\u0c39\u0c3b\5\u01e8\u00f5\2\u0c3a\u0c39\3\2\2\2\u0c3a\u0c3b\3\2\2\2"+
"\u0c3b\u0c3d\3\2\2\2\u0c3c\u0c3e\5\u01ea\u00f6\2\u0c3d\u0c3c\3\2\2\2\u0c3d"+
"\u0c3e\3\2\2\2\u0c3e\u0c40\3\2\2\2\u0c3f\u0c41\5\u01ec\u00f7\2\u0c40\u0c3f"+
"\3\2\2\2\u0c40\u0c41\3\2\2\2\u0c41\u0c43\3\2\2\2\u0c42\u0c44\5\u01ee\u00f8"+
"\2\u0c43\u0c42\3\2\2\2\u0c43\u0c44\3\2\2\2\u0c44\u0c46\3\2\2\2\u0c45\u0c47"+
"\5\u01f0\u00f9\2\u0c46\u0c45\3\2\2\2\u0c46\u0c47\3\2\2\2\u0c47\u0c49\3"+
"\2\2\2\u0c48\u0c4a\5\u01f2\u00fa\2\u0c49\u0c48\3\2\2\2\u0c49\u0c4a\3\2"+
"\2\2\u0c4a\u0c4c\3\2\2\2\u0c4b\u0c4d\5\u01f4\u00fb\2\u0c4c\u0c4b\3\2\2"+
"\2\u0c4c\u0c4d\3\2\2\2\u0c4d\u0c4f\3\2\2\2\u0c4e\u0c50\5\u01f6\u00fc\2"+
"\u0c4f\u0c4e\3\2\2\2\u0c4f\u0c50\3\2\2\2\u0c50\u0cae\3\2\2\2\u0c51\u0c53"+
"\5\u01e8\u00f5\2\u0c52\u0c54\5\u01ea\u00f6\2\u0c53\u0c52\3\2\2\2\u0c53"+
"\u0c54\3\2\2\2\u0c54\u0c56\3\2\2\2\u0c55\u0c57\5\u01ec\u00f7\2\u0c56\u0c55"+
"\3\2\2\2\u0c56\u0c57\3\2\2\2\u0c57\u0c59\3\2\2\2\u0c58\u0c5a\5\u01ee\u00f8"+
"\2\u0c59\u0c58\3\2\2\2\u0c59\u0c5a\3\2\2\2\u0c5a\u0c5c\3\2\2\2\u0c5b\u0c5d"+
"\5\u01f0\u00f9\2\u0c5c\u0c5b\3\2\2\2\u0c5c\u0c5d\3\2\2\2\u0c5d\u0c5f\3"+
"\2\2\2\u0c5e\u0c60\5\u01f2\u00fa\2\u0c5f\u0c5e\3\2\2\2\u0c5f\u0c60\3\2"+
"\2\2\u0c60\u0c62\3\2\2\2\u0c61\u0c63\5\u01f4\u00fb\2\u0c62\u0c61\3\2\2"+
"\2\u0c62\u0c63\3\2\2\2\u0c63\u0c65\3\2\2\2\u0c64\u0c66\5\u01f6\u00fc\2"+
"\u0c65\u0c64\3\2\2\2\u0c65\u0c66\3\2\2\2\u0c66\u0cae\3\2\2\2\u0c67\u0c69"+
"\5\u01ea\u00f6\2\u0c68\u0c6a\5\u01ec\u00f7\2\u0c69\u0c68\3\2\2\2\u0c69"+
"\u0c6a\3\2\2\2\u0c6a\u0c6c\3\2\2\2\u0c6b\u0c6d\5\u01ee\u00f8\2\u0c6c\u0c6b"+
"\3\2\2\2\u0c6c\u0c6d\3\2\2\2\u0c6d\u0c6f\3\2\2\2\u0c6e\u0c70\5\u01f0\u00f9"+
"\2\u0c6f\u0c6e\3\2\2\2\u0c6f\u0c70\3\2\2\2\u0c70\u0c72\3\2\2\2\u0c71\u0c73"+
"\5\u01f2\u00fa\2\u0c72\u0c71\3\2\2\2\u0c72\u0c73\3\2\2\2\u0c73\u0c75\3"+
"\2\2\2\u0c74\u0c76\5\u01f4\u00fb\2\u0c75\u0c74\3\2\2\2\u0c75\u0c76\3\2"+
"\2\2\u0c76\u0c78\3\2\2\2\u0c77\u0c79\5\u01f6\u00fc\2\u0c78\u0c77\3\2\2"+
"\2\u0c78\u0c79\3\2\2\2\u0c79\u0cae\3\2\2\2\u0c7a\u0c7c\5\u01ec\u00f7\2"+
"\u0c7b\u0c7d\5\u01ee\u00f8\2\u0c7c\u0c7b\3\2\2\2\u0c7c\u0c7d\3\2\2\2\u0c7d"+
"\u0c7f\3\2\2\2\u0c7e\u0c80\5\u01f0\u00f9\2\u0c7f\u0c7e\3\2\2\2\u0c7f\u0c80"+
"\3\2\2\2\u0c80\u0c82\3\2\2\2\u0c81\u0c83\5\u01f2\u00fa\2\u0c82\u0c81\3"+
"\2\2\2\u0c82\u0c83\3\2\2\2\u0c83\u0c85\3\2\2\2\u0c84\u0c86\5\u01f4\u00fb"+
"\2\u0c85\u0c84\3\2\2\2\u0c85\u0c86\3\2\2\2\u0c86\u0c88\3\2\2\2\u0c87\u0c89"+
"\5\u01f6\u00fc\2\u0c88\u0c87\3\2\2\2\u0c88\u0c89\3\2\2\2\u0c89\u0cae\3"+
"\2\2\2\u0c8a\u0c8c\5\u01ee\u00f8\2\u0c8b\u0c8d\5\u01f0\u00f9\2\u0c8c\u0c8b"+
"\3\2\2\2\u0c8c\u0c8d\3\2\2\2\u0c8d\u0c8f\3\2\2\2\u0c8e\u0c90\5\u01f2\u00fa"+
"\2\u0c8f\u0c8e\3\2\2\2\u0c8f\u0c90\3\2\2\2\u0c90\u0c92\3\2\2\2\u0c91\u0c93"+
"\5\u01f4\u00fb\2\u0c92\u0c91\3\2\2\2\u0c92\u0c93\3\2\2\2\u0c93\u0c95\3"+
"\2\2\2\u0c94\u0c96\5\u01f6\u00fc\2\u0c95\u0c94\3\2\2\2\u0c95\u0c96\3\2"+
"\2\2\u0c96\u0cae\3\2\2\2\u0c97\u0c99\5\u01f0\u00f9\2\u0c98\u0c9a\5\u01f2"+
"\u00fa\2\u0c99\u0c98\3\2\2\2\u0c99\u0c9a\3\2\2\2\u0c9a\u0c9c\3\2\2\2\u0c9b"+
"\u0c9d\5\u01f4\u00fb\2\u0c9c\u0c9b\3\2\2\2\u0c9c\u0c9d\3\2\2\2\u0c9d\u0c9f"+
"\3\2\2\2\u0c9e\u0ca0\5\u01f6\u00fc\2\u0c9f\u0c9e\3\2\2\2\u0c9f\u0ca0\3"+
"\2\2\2\u0ca0\u0cae\3\2\2\2\u0ca1\u0ca3\5\u01f2\u00fa\2\u0ca2\u0ca4\5\u01f4"+
"\u00fb\2\u0ca3\u0ca2\3\2\2\2\u0ca3\u0ca4\3\2\2\2\u0ca4\u0ca6\3\2\2\2\u0ca5"+
"\u0ca7\5\u01f6\u00fc\2\u0ca6\u0ca5\3\2\2\2\u0ca6\u0ca7\3\2\2\2\u0ca7\u0cae"+
"\3\2\2\2\u0ca8\u0caa\5\u01f4\u00fb\2\u0ca9\u0cab\5\u01f6\u00fc\2\u0caa"+
"\u0ca9\3\2\2\2\u0caa\u0cab\3\2\2\2\u0cab\u0cae\3\2\2\2\u0cac\u0cae\5\u01f6"+
"\u00fc\2\u0cad\u0c38\3\2\2\2\u0cad\u0c51\3\2\2\2\u0cad\u0c67\3\2\2\2\u0cad"+
"\u0c7a\3\2\2\2\u0cad\u0c8a\3\2\2\2\u0cad\u0c97\3\2\2\2\u0cad\u0ca1\3\2"+
"\2\2\u0cad\u0ca8\3\2\2\2\u0cad\u0cac\3\2\2\2\u0cae\u01e5\3\2\2\2\u0caf"+
"\u0cb3\5\u0200\u0101\2\u0cb0\u0cb3\7\u00c7\2\2\u0cb1\u0cb3\5\u01fa\u00fe"+
"\2\u0cb2\u0caf\3\2\2\2\u0cb2\u0cb0\3\2\2\2\u0cb2\u0cb1\3\2\2\2\u0cb3\u0cb4"+
"\3\2\2\2\u0cb4\u0cb5\t\13\2\2\u0cb5\u01e7\3\2\2\2\u0cb6\u0cba\5\u0200"+
"\u0101\2\u0cb7\u0cba\7\u00c7\2\2\u0cb8\u0cba\5\u01fa\u00fe\2\u0cb9\u0cb6"+
"\3\2\2\2\u0cb9\u0cb7\3\2\2\2\u0cb9\u0cb8\3\2\2\2\u0cba\u0cbb\3\2\2\2\u0cbb"+
"\u0cbc\t\f\2\2\u0cbc\u01e9\3\2\2\2\u0cbd\u0cc1\5\u0200\u0101\2\u0cbe\u0cc1"+
"\7\u00c7\2\2\u0cbf\u0cc1\5\u01fa\u00fe\2\u0cc0\u0cbd\3\2\2\2\u0cc0\u0cbe"+
"\3\2\2\2\u0cc0\u0cbf\3\2\2\2\u0cc1\u0cc2\3\2\2\2\u0cc2\u0cc3\t\r\2\2\u0cc3"+
"\u01eb\3\2\2\2\u0cc4\u0cc8\5\u0200\u0101\2\u0cc5\u0cc8\7\u00c7\2\2\u0cc6"+
"\u0cc8\5\u01fa\u00fe\2\u0cc7\u0cc4\3\2\2\2\u0cc7\u0cc5\3\2\2\2\u0cc7\u0cc6"+
"\3\2\2\2\u0cc8\u0cc9\3\2\2\2\u0cc9\u0cca\t\16\2\2\u0cca\u01ed\3\2\2\2"+
"\u0ccb\u0ccf\5\u0200\u0101\2\u0ccc\u0ccf\7\u00c7\2\2\u0ccd\u0ccf\5\u01fa"+
"\u00fe\2\u0cce\u0ccb\3\2\2\2\u0cce\u0ccc\3\2\2\2\u0cce\u0ccd\3\2\2\2\u0ccf"+
"\u0cd0\3\2\2\2\u0cd0\u0cd1\t\17\2\2\u0cd1\u01ef\3\2\2\2\u0cd2\u0cd6\5"+
"\u0200\u0101\2\u0cd3\u0cd6\7\u00c7\2\2\u0cd4\u0cd6\5\u01fa\u00fe\2\u0cd5"+
"\u0cd2\3\2\2\2\u0cd5\u0cd3\3\2\2\2\u0cd5\u0cd4\3\2\2\2\u0cd6\u0cd7\3\2"+
"\2\2\u0cd7\u0cd8\t\20\2\2\u0cd8\u01f1\3\2\2\2\u0cd9\u0cdd\5\u0200\u0101"+
"\2\u0cda\u0cdd\7\u00c7\2\2\u0cdb\u0cdd\5\u01fa\u00fe\2\u0cdc\u0cd9\3\2"+
"\2\2\u0cdc\u0cda\3\2\2\2\u0cdc\u0cdb\3\2\2\2\u0cdd\u0cde\3\2\2\2\u0cde"+
"\u0cdf\t\21\2\2\u0cdf\u01f3\3\2\2\2\u0ce0\u0ce4\5\u0200\u0101\2\u0ce1"+
"\u0ce4\7\u00c7\2\2\u0ce2\u0ce4\5\u01fa\u00fe\2\u0ce3\u0ce0\3\2\2\2\u0ce3"+
"\u0ce1\3\2\2\2\u0ce3\u0ce2\3\2\2\2\u0ce4\u0ce5\3\2\2\2\u0ce5\u0ce6\t\22"+
"\2\2\u0ce6\u01f5\3\2\2\2\u0ce7\u0ceb\5\u0200\u0101\2\u0ce8\u0ceb\7\u00c7"+
"\2\2\u0ce9\u0ceb\5\u01fa\u00fe\2\u0cea\u0ce7\3\2\2\2\u0cea\u0ce8\3\2\2"+
"\2\u0cea\u0ce9\3\2\2\2\u0ceb\u0cec\3\2\2\2\u0cec\u0ced\t\23\2\2\u0ced"+
"\u01f7\3\2\2\2\u0cee\u0cef\t\24\2\2\u0cef\u01f9\3\2\2\2\u0cf0\u0cf9\7"+
"\u0092\2\2\u0cf1\u0cf3\7\u0099\2\2\u0cf2\u0cf4\5\u01fc\u00ff\2\u0cf3\u0cf2"+
"\3\2\2\2\u0cf3\u0cf4\3\2\2\2\u0cf4\u0cf7\3\2\2\2\u0cf5\u0cf6\7\u0099\2"+
"\2\u0cf6\u0cf8\5\u019e\u00d0\2\u0cf7\u0cf5\3\2\2\2\u0cf7\u0cf8\3\2\2\2"+
"\u0cf8\u0cfa\3\2\2\2\u0cf9\u0cf1\3\2\2\2\u0cf9\u0cfa\3\2\2\2\u0cfa\u01fb"+
"\3\2\2\2\u0cfb\u0cfd\7\u009f\2\2\u0cfc\u0cfb\3\2\2\2\u0cfc\u0cfd\3\2\2"+
"\2\u0cfd\u0cfe\3\2\2\2\u0cfe\u0d03\5\u01e0\u00f1\2\u0cff\u0d00\7\u009f"+
"\2\2\u0d00\u0d02\5\u01e0\u00f1\2\u0d01\u0cff\3\2\2\2\u0d02\u0d05\3\2\2"+
"\2\u0d03\u0d01\3\2\2\2\u0d03\u0d04\3\2\2\2\u0d04\u01fd\3\2\2\2\u0d05\u0d03"+
"\3\2\2\2\u0d06\u0d0c\5\u0200\u0101\2\u0d07\u0d0c\5\u0202\u0102\2\u0d08"+
"\u0d0c\7m\2\2\u0d09\u0d0c\7n\2\2\u0d0a\u0d0c\7o\2\2\u0d0b\u0d06\3\2\2"+
"\2\u0d0b\u0d07\3\2\2\2\u0d0b\u0d08\3\2\2\2\u0d0b\u0d09\3\2\2\2\u0d0b\u0d0a"+
"\3\2\2\2\u0d0c\u01ff\3\2\2\2\u0d0d\u0d10\7\u00a4\2\2\u0d0e\u0d10\7\u00a1"+
"\2\2\u0d0f\u0d0d\3\2\2\2\u0d0f\u0d0e\3\2\2\2\u0d0f\u0d10\3\2\2\2\u0d10"+
"\u0d11\3\2\2\2\u0d11\u0d12\5\u01f8\u00fd\2\u0d12\u0201\3\2\2\2\u0d13\u0d16"+
"\7\u00c5\2\2\u0d14\u0d16\7\u00c4\2\2\u0d15\u0d13\3\2\2\2\u0d15\u0d14\3"+
"\2\2\2\u0d16\u0203\3\2\2\2\u0d17\u0d1b\5\u01fe\u0100\2\u0d18\u0d1b\5\u0206"+
"\u0104\2\u0d19\u0d1b\5\u0208\u0105\2\u0d1a\u0d17\3\2\2\2\u0d1a\u0d18\3"+
"\2\2\2\u0d1a\u0d19\3\2\2\2\u0d1b\u0205\3\2\2\2\u0d1c\u0d1d\7\u0097\2\2"+
"\u0d1d\u0d1e\5\u020c\u0107\2\u0d1e\u0d1f\7\u0098\2\2\u0d1f\u0207\3\2\2"+
"\2\u0d20\u0d22\7\u0095\2\2\u0d21\u0d23\5\u020a\u0106\2\u0d22\u0d21\3\2"+
"\2\2\u0d22\u0d23\3\2\2\2\u0d23\u0d24\3\2\2\2\u0d24\u0d25\7\u0096\2\2\u0d25"+
"\u0209\3\2\2\2\u0d26\u0d2b\5\u0204\u0103\2\u0d27\u0d28\7\u009a\2\2\u0d28"+
"\u0d2a\5\u0204\u0103\2\u0d29\u0d27\3\2\2\2\u0d2a\u0d2d\3\2\2\2\u0d2b\u0d29"+
"\3\2\2\2\u0d2b\u0d2c\3\2\2\2\u0d2c\u0d2f\3\2\2\2\u0d2d\u0d2b\3\2\2\2\u0d2e"+
"\u0d30\7\u009a\2\2\u0d2f\u0d2e\3\2\2\2\u0d2f\u0d30\3\2\2\2\u0d30\u020b"+
"\3\2\2\2\u0d31\u0d36\5\u020e\u0108\2\u0d32\u0d33\7\u009a\2\2\u0d33\u0d35"+
"\5\u020e\u0108\2\u0d34\u0d32\3\2\2\2\u0d35\u0d38\3\2\2\2\u0d36\u0d34\3"+
"\2\2\2\u0d36\u0d37\3\2\2\2\u0d37\u0d3a\3\2\2\2\u0d38\u0d36\3\2\2\2\u0d39"+
"\u0d3b\7\u009a\2\2\u0d3a\u0d39\3\2\2\2\u0d3a\u0d3b\3\2\2\2\u0d3b\u020d"+
"\3\2\2\2\u0d3c\u0d3f\5\u0202\u0102\2\u0d3d\u0d3f\5\u01de\u00f0\2\u0d3e"+
"\u0d3c\3\2\2\2\u0d3e\u0d3d\3\2\2\2\u0d3f\u0d40\3\2\2\2\u0d40\u0d41\7\u0099"+
"\2\2\u0d41\u0d42\5\u0204\u0103\2\u0d42\u020f\3\2\2\2\u01da\u0213\u0215"+
"\u0228\u022b\u022e\u0233\u0236\u023a\u0243\u024c\u0253\u0262\u0265\u026c"+
"\u0278\u0280\u0283\u0286\u028b\u029c\u029f\u02a6\u02aa\u02b0\u02b3\u02b7"+
"\u02bc\u02c0\u02c4\u02c9\u02cd\u02d6\u02d9\u02db\u02e0\u02e4\u02e9\u02f3"+
"\u02f9\u02fd\u0303\u0308\u030d\u030f\u0313\u0319\u031e\u0327\u032c\u032f"+
"\u0336\u0340\u0345\u034d\u0353\u0356\u035c\u0360\u0364\u0367\u036a\u036e"+
"\u0372\u0377\u037b\u0380\u0384\u038b\u0391\u0398\u039c\u03a3\u03a8\u03ae"+
"\u03b8\u03c0\u03c7\u03cd\u03d1\u03d4\u03db\u03e0\u03e2\u03e8\u03ee\u03fd"+
"\u0403\u0406\u040b\u040e\u0410\u0414\u041b\u0421\u042c\u0433\u0436\u0439"+
"\u043d\u043f\u0447\u044d\u0454\u045b\u0461\u0465\u046c\u0471\u0474\u0479"+
"\u0482\u0486\u0493\u049e\u04a6\u04ac\u04b1\u04b4\u04b7\u04bb\u04be\u04c4"+
"\u04cf\u04d4\u04d7\u04e9\u04ee\u04f6\u04fd\u0501\u0508\u0516\u0518\u051e"+
"\u0530\u0533\u0538\u0540\u0544\u0548\u054b\u0550\u0555\u0558\u055c\u0563"+
"\u0567\u056a\u0571\u0579\u0580\u0586\u0588\u058d\u0595\u0598\u059b\u05a0"+
"\u05a4\u05a7\u05ae\u05b4\u05b7\u05bf\u05c7\u05ce\u05d3\u05df\u05e4\u05ec"+
"\u05f2\u05f5\u05f8\u0604\u060c\u0612\u0618\u061f\u0625\u0628\u062b\u0630"+
"\u0638\u0644\u0647\u0650\u0656\u065a\u065d\u0660\u066a\u0670\u0673\u0678"+
"\u067b\u067f\u0685\u0688\u068e\u069b\u06a0\u06a2\u06ab\u06ae\u06b1\u06b9"+
"\u06c2\u06c5\u06cd\u06d3\u06d7\u06da\u06e1\u06e7\u06f0\u06fd\u0704\u070d"+
"\u0710\u0713\u071a\u0720\u0725\u072b\u0731\u0734\u073c\u0742\u0746\u0749"+
"\u074c\u0753\u0757\u075e\u0762\u0766\u076a\u076c\u0773\u0785\u0789\u078c"+
"\u0790\u0793\u079e\u07a7\u07ad\u07af\u07c4\u07cb\u07d1\u07d6\u07de\u07e1"+
"\u07ea\u07f3\u07f6\u07f8\u07fb\u07ff\u0802\u0805\u080f\u081d\u0820\u082b"+
"\u082e\u0834\u083b\u0843\u084b\u0851\u085a\u0860\u0864\u0868\u086a\u086e"+
"\u0876\u087c\u0880\u0884\u0886\u088a\u088e\u0893\u089c\u089f\u08a3\u08ad"+
"\u08b1\u08b3\u08be\u08c1\u08c8\u08d0\u08e7\u08f4\u08f7\u0903\u0906\u090e"+
"\u0913\u091e\u092b\u0932\u0937\u093b\u0941\u0946\u094a\u0952\u0955\u095d"+
"\u0965\u096e\u0976\u097e\u0986\u0995\u099f\u09a9\u09d3\u09e4\u09f1\u09f7"+
"\u09fc\u0a00\u0a08\u0a0b\u0a17\u0a1a\u0a21\u0a25\u0a33\u0a3c\u0a45\u0a4d"+
"\u0a51\u0a56\u0a5c\u0a5f\u0a61\u0a6a\u0a70\u0a78\u0a81\u0a87\u0a8b\u0a94"+
"\u0aa0\u0aa2\u0aa6\u0aac\u0ab1\u0ab4\u0ab7\u0abd\u0ac2\u0ac6\u0aca\u0ace"+
"\u0adb\u0ae3\u0ae5\u0aec\u0af6\u0afb\u0afe\u0b01\u0b04\u0b0c\u0b10\u0b14"+
"\u0b19\u0b22\u0b29\u0b32\u0b3a\u0b42\u0b47\u0b4b\u0b52\u0b55\u0b5c\u0b5f"+
"\u0b66\u0b6e\u0b7b\u0b7f\u0b87\u0b92\u0b97\u0b9d\u0ba2\u0ba9\u0bb3\u0bbb"+
"\u0bc2\u0bc7\u0bcc\u0bd1\u0bd9\u0be1\u0be4\u0bea\u0bee\u0bf3\u0c2d\u0c32"+
"\u0c36\u0c3a\u0c3d\u0c40\u0c43\u0c46\u0c49\u0c4c\u0c4f\u0c53\u0c56\u0c59"+
"\u0c5c\u0c5f\u0c62\u0c65\u0c69\u0c6c\u0c6f\u0c72\u0c75\u0c78\u0c7c\u0c7f"+
"\u0c82\u0c85\u0c88\u0c8c\u0c8f\u0c92\u0c95\u0c99\u0c9c\u0c9f\u0ca3\u0ca6"+
"\u0caa\u0cad\u0cb2\u0cb9\u0cc0\u0cc7\u0cce\u0cd5\u0cdc\u0ce3\u0cea\u0cf3"+
"\u0cf7\u0cf9\u0cfc\u0d03\u0d0b\u0d0f\u0d15\u0d1a\u0d22\u0d2b\u0d2f\u0d36"+
"\u0d3a\u0d3e";
public static final String _serializedATN = Utils.join(
new String[] {
_serializedATNSegment0,
_serializedATNSegment1
},
""
);
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);
}
}
}
