// Generated from EsperEPL2Grammar.g by ANTLR 4.5.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.epl.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.5.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, NEWKW=126, START=127, CONTEXT=128,
INITIATED=129, TERMINATED=130, DATAFLOW=131, CUBE=132, ROLLUP=133, GROUPING=134,
GROUPING_ID=135, SETS=136, FOLLOWMAX_BEGIN=137, FOLLOWMAX_END=138, FOLLOWED_BY=139,
GOES=140, EQUALS=141, SQL_NE=142, QUESTION=143, LPAREN=144, RPAREN=145,
LBRACK=146, RBRACK=147, LCURLY=148, RCURLY=149, COLON=150, COMMA=151,
EQUAL=152, LNOT=153, BNOT=154, NOT_EQUAL=155, DIV=156, DIV_ASSIGN=157,
PLUS=158, PLUS_ASSIGN=159, INC=160, MINUS=161, MINUS_ASSIGN=162, DEC=163,
STAR=164, STAR_ASSIGN=165, MOD=166, MOD_ASSIGN=167, GE=168, GT=169, LE=170,
LT=171, BXOR=172, BXOR_ASSIGN=173, BOR=174, BOR_ASSIGN=175, LOR=176, BAND=177,
BAND_ASSIGN=178, LAND=179, SEMI=180, DOT=181, NUM_LONG=182, NUM_DOUBLE=183,
NUM_FLOAT=184, ESCAPECHAR=185, ESCAPEBACKTICK=186, ATCHAR=187, HASHCHAR=188,
WS=189, SL_COMMENT=190, ML_COMMENT=191, TICKED_STRING_LITERAL=192, QUOTED_STRING_LITERAL=193,
STRING_LITERAL=194, IDENT=195, IntegerLiteral=196, FloatingPointLiteral=197;
public static final int
RULE_startPatternExpressionRule = 0, RULE_startEPLExpressionRule = 1,
RULE_startEventPropertyRule = 2, RULE_startJsonValueRule = 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_mergeUnmatched = 25, RULE_mergeUnmatchedItem = 26, RULE_mergeInsert = 27,
RULE_onSelectExpr = 28, RULE_onUpdateExpr = 29, RULE_onSelectInsertExpr = 30,
RULE_onSelectInsertFromClause = 31, RULE_outputClauseInsert = 32, RULE_onDeleteExpr = 33,
RULE_onSetExpr = 34, RULE_onSetAssignmentList = 35, RULE_onSetAssignment = 36,
RULE_onExprFrom = 37, RULE_createWindowExpr = 38, RULE_createWindowExprModelAfter = 39,
RULE_createIndexExpr = 40, RULE_createIndexColumnList = 41, RULE_createIndexColumn = 42,
RULE_createVariableExpr = 43, RULE_createTableExpr = 44, RULE_createTableColumnList = 45,
RULE_createTableColumn = 46, RULE_createTableColumnPlain = 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_createDataflow = 57, RULE_gopList = 58,
RULE_gop = 59, RULE_gopParams = 60, RULE_gopParamsItemList = 61, RULE_gopParamsItem = 62,
RULE_gopParamsItemMany = 63, RULE_gopParamsItemAs = 64, RULE_gopOut = 65,
RULE_gopOutItem = 66, RULE_gopOutTypeList = 67, RULE_gopOutTypeParam = 68,
RULE_gopOutTypeItem = 69, RULE_gopDetail = 70, RULE_gopConfig = 71, RULE_createContextExpr = 72,
RULE_createExpressionExpr = 73, RULE_createContextDetail = 74, RULE_contextContextNested = 75,
RULE_createContextChoice = 76, RULE_createContextDistinct = 77, RULE_createContextRangePoint = 78,
RULE_createContextFilter = 79, RULE_createContextPartitionItem = 80, RULE_createContextCoalesceItem = 81,
RULE_createContextGroupItem = 82, RULE_createSchemaQual = 83, RULE_variantList = 84,
RULE_variantListElement = 85, RULE_intoTableExpr = 86, RULE_insertIntoExpr = 87,
RULE_columnList = 88, RULE_fromClause = 89, RULE_regularJoin = 90, RULE_outerJoinList = 91,
RULE_outerJoin = 92, RULE_outerJoinIdent = 93, RULE_outerJoinIdentPair = 94,
RULE_whereClause = 95, RULE_selectClause = 96, RULE_selectionList = 97,
RULE_selectionListElement = 98, RULE_selectionListElementExpr = 99, RULE_selectionListElementAnno = 100,
RULE_streamSelector = 101, RULE_streamExpression = 102, RULE_forExpr = 103,
RULE_patternInclusionExpression = 104, RULE_databaseJoinExpression = 105,
RULE_methodJoinExpression = 106, RULE_viewExpressions = 107, RULE_viewExpressionWNamespace = 108,
RULE_viewExpressionOptNamespace = 109, RULE_viewWParameters = 110, RULE_groupByListExpr = 111,
RULE_groupByListChoice = 112, RULE_groupByCubeOrRollup = 113, RULE_groupByGroupingSets = 114,
RULE_groupBySetsChoice = 115, RULE_groupByCombinableExpr = 116, RULE_orderByListExpr = 117,
RULE_orderByListElement = 118, RULE_havingClause = 119, RULE_outputLimit = 120,
RULE_outputLimitAndTerm = 121, RULE_outputLimitAfter = 122, RULE_rowLimit = 123,
RULE_crontabLimitParameterSet = 124, RULE_whenClause = 125, RULE_elseClause = 126,
RULE_matchRecog = 127, RULE_matchRecogPartitionBy = 128, RULE_matchRecogMeasures = 129,
RULE_matchRecogMeasureItem = 130, RULE_matchRecogMatchesSelection = 131,
RULE_matchRecogPattern = 132, RULE_matchRecogMatchesAfterSkip = 133, RULE_matchRecogMatchesInterval = 134,
RULE_matchRecogPatternAlteration = 135, RULE_matchRecogPatternConcat = 136,
RULE_matchRecogPatternUnary = 137, RULE_matchRecogPatternNested = 138,
RULE_matchRecogPatternPermute = 139, RULE_matchRecogPatternAtom = 140,
RULE_matchRecogPatternRepeat = 141, RULE_matchRecogDefine = 142, RULE_matchRecogDefineItem = 143,
RULE_expression = 144, RULE_caseExpression = 145, RULE_evalOrExpression = 146,
RULE_evalAndExpression = 147, RULE_bitWiseExpression = 148, RULE_negatedExpression = 149,
RULE_evalEqualsExpression = 150, RULE_evalRelationalExpression = 151,
RULE_inSubSelectQuery = 152, RULE_concatenationExpr = 153, RULE_additiveExpression = 154,
RULE_multiplyExpression = 155, RULE_unaryExpression = 156, RULE_substitutionCanChain = 157,
RULE_chainedFunction = 158, RULE_newAssign = 159, RULE_rowSubSelectExpression = 160,
RULE_subSelectGroupExpression = 161, RULE_existsSubSelectExpression = 162,
RULE_subQueryExpr = 163, RULE_subSelectFilterExpr = 164, RULE_arrayExpression = 165,
RULE_builtinFunc = 166, RULE_firstLastWindowAggregation = 167, RULE_eventPropertyOrLibFunction = 168,
RULE_libFunction = 169, RULE_libFunctionWithClass = 170, RULE_libFunctionNoClass = 171,
RULE_funcIdentTop = 172, RULE_funcIdentInner = 173, RULE_funcIdentChained = 174,
RULE_libFunctionArgs = 175, RULE_libFunctionArgItem = 176, RULE_betweenList = 177,
RULE_patternExpression = 178, RULE_followedByExpression = 179, RULE_followedByRepeat = 180,
RULE_orExpression = 181, RULE_andExpression = 182, RULE_matchUntilExpression = 183,
RULE_qualifyExpression = 184, RULE_guardPostFix = 185, RULE_distinctExpressionList = 186,
RULE_distinctExpressionAtom = 187, RULE_atomicExpression = 188, RULE_observerExpression = 189,
RULE_guardWhereExpression = 190, RULE_guardWhileExpression = 191, RULE_matchUntilRange = 192,
RULE_eventFilterExpression = 193, RULE_propertyExpression = 194, RULE_propertyExpressionAtomic = 195,
RULE_propertyExpressionSelect = 196, RULE_propertySelectionList = 197,
RULE_propertySelectionListElement = 198, RULE_propertyStreamSelector = 199,
RULE_typeExpressionAnnotation = 200, RULE_patternFilterExpression = 201,
RULE_patternFilterAnnotation = 202, RULE_classIdentifier = 203, RULE_slashIdentifier = 204,
RULE_expressionListWithNamed = 205, RULE_expressionListWithNamedWithTime = 206,
RULE_expressionWithNamed = 207, RULE_expressionWithNamedWithTime = 208,
RULE_expressionNamedParameter = 209, RULE_expressionNamedParameterWithTime = 210,
RULE_expressionList = 211, RULE_expressionWithTimeList = 212, RULE_expressionWithTime = 213,
RULE_expressionWithTimeInclLast = 214, RULE_expressionQualifyable = 215,
RULE_lastWeekdayOperand = 216, RULE_lastOperand = 217, RULE_frequencyOperand = 218,
RULE_rangeOperand = 219, RULE_lastOperator = 220, RULE_weekDayOperator = 221,
RULE_numericParameterList = 222, RULE_numericListParameter = 223, RULE_eventProperty = 224,
RULE_eventPropertyAtomic = 225, RULE_eventPropertyIdent = 226, RULE_keywordAllowedIdent = 227,
RULE_escapableStr = 228, RULE_escapableIdent = 229, RULE_timePeriod = 230,
RULE_yearPart = 231, RULE_monthPart = 232, RULE_weekPart = 233, RULE_dayPart = 234,
RULE_hourPart = 235, RULE_minutePart = 236, RULE_secondPart = 237, RULE_millisecondPart = 238,
RULE_microsecondPart = 239, RULE_number = 240, RULE_substitution = 241,
RULE_constant = 242, RULE_numberconstant = 243, RULE_stringconstant = 244,
RULE_jsonvalue = 245, RULE_jsonobject = 246, RULE_jsonarray = 247, RULE_jsonelements = 248,
RULE_jsonmembers = 249, RULE_jsonpair = 250;
public static final String[] ruleNames = {
"startPatternExpressionRule", "startEPLExpressionRule", "startEventPropertyRule",
"startJsonValueRule", "expressionDecl", "expressionDialect", "expressionDef",
"expressionLambdaDecl", "expressionTypeAnno", "annotationEnum", "elementValuePairsEnum",
"elementValuePairEnum", "elementValueEnum", "elementValueArrayEnum", "eplExpression",
"contextExpr", "selectExpr", "onExpr", "onStreamExpr", "updateExpr", "updateDetails",
"onMergeExpr", "mergeItem", "mergeMatched", "mergeMatchedItem", "mergeUnmatched",
"mergeUnmatchedItem", "mergeInsert", "onSelectExpr", "onUpdateExpr", "onSelectInsertExpr",
"onSelectInsertFromClause", "outputClauseInsert", "onDeleteExpr", "onSetExpr",
"onSetAssignmentList", "onSetAssignment", "onExprFrom", "createWindowExpr",
"createWindowExprModelAfter", "createIndexExpr", "createIndexColumnList",
"createIndexColumn", "createVariableExpr", "createTableExpr", "createTableColumnList",
"createTableColumn", "createTableColumnPlain", "createColumnList", "createColumnListElement",
"createSelectionList", "createSelectionListElement", "createSchemaExpr",
"createSchemaDef", "fafDelete", "fafUpdate", "fafInsert", "createDataflow",
"gopList", "gop", "gopParams", "gopParamsItemList", "gopParamsItem", "gopParamsItemMany",
"gopParamsItemAs", "gopOut", "gopOutItem", "gopOutTypeList", "gopOutTypeParam",
"gopOutTypeItem", "gopDetail", "gopConfig", "createContextExpr", "createExpressionExpr",
"createContextDetail", "contextContextNested", "createContextChoice",
"createContextDistinct", "createContextRangePoint", "createContextFilter",
"createContextPartitionItem", "createContextCoalesceItem", "createContextGroupItem",
"createSchemaQual", "variantList", "variantListElement", "intoTableExpr",
"insertIntoExpr", "columnList", "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", "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",
"substitutionCanChain", "chainedFunction", "newAssign", "rowSubSelectExpression",
"subSelectGroupExpression", "existsSubSelectExpression", "subQueryExpr",
"subSelectFilterExpr", "arrayExpression", "builtinFunc", "firstLastWindowAggregation",
"eventPropertyOrLibFunction", "libFunction", "libFunctionWithClass", "libFunctionNoClass",
"funcIdentTop", "funcIdentInner", "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", "classIdentifier", "slashIdentifier", "expressionListWithNamed",
"expressionListWithNamedWithTime", "expressionWithNamed", "expressionWithNamedWithTime",
"expressionNamedParameter", "expressionNamedParameterWithTime", "expressionList",
"expressionWithTimeList", "expressionWithTime", "expressionWithTimeInclLast",
"expressionQualifyable", "lastWeekdayOperand", "lastOperand", "frequencyOperand",
"rangeOperand", "lastOperator", "weekDayOperator", "numericParameterList",
"numericListParameter", "eventProperty", "eventPropertyAtomic", "eventPropertyIdent",
"keywordAllowedIdent", "escapableStr", "escapableIdent", "timePeriod",
"yearPart", "monthPart", "weekPart", "dayPart", "hourPart", "minutePart",
"secondPart", "millisecondPart", "microsecondPart", "number", "substitution",
"constant", "numberconstant", "stringconstant", "jsonvalue", "jsonobject",
"jsonarray", "jsonelements", "jsonmembers", "jsonpair"
};
private static final String[] _LITERAL_NAMES = {
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'", "'new'",
"'start'", "'context'", "'initiated'", "'terminated'", "'dataflow'", "'cube'",
"'rollup'", "'grouping'", "'grouping_id'", "'sets'", "'-['", "']>'", "'->'",
"'=>'", "'='", "'<>'", "'?'", "'('", "')'", "'['", "']'", "'{'", "'}'",
"':'", "','", "'=='", "'!'", "'~'", "'!='", "'/'", "'/='", "'+'", "'+='",
"'++'", "'-'", "'-='", "'--'", "'*'", "'*='", "'%'", "'%='", "'>='", "'>'",
"'<='", "'<'", "'^'", "'^='", "'|'", "'|='", "'||'", "'&'", "'&='", "'&&'",
"';'", "'.'", "'\\u18FF'", "'\\u18FE'", "'\\u18FD'", "'\\'", "'`'", "'@'",
"'#'"
};
private static final String[] _SYMBOLIC_NAMES = {
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", "NEWKW", "START", "CONTEXT",
"INITIATED", "TERMINATED", "DATAFLOW", "CUBE", "ROLLUP", "GROUPING", "GROUPING_ID",
"SETS", "FOLLOWMAX_BEGIN", "FOLLOWMAX_END", "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", "IDENT", "IntegerLiteral",
"FloatingPointLiteral"
};
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] = "<INVALID>";
}
}
}
@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<String> paraphrases = new java.util.Stack<String>();
// static information initialized once
private static java.util.Map<Integer, String> lexerTokenParaphases = new java.util.HashMap<Integer, String>();
private static java.util.Map<Integer, String> parserTokenParaphases = new java.util.HashMap<Integer, String>();
private static java.util.Set<String> parserKeywordSet = new java.util.HashSet<String>();
private static java.util.Set<Integer> afterScriptTokens = new java.util.HashSet<Integer>();
public java.util.Stack getParaphrases() {
return paraphrases;
}
public java.util.Set<String> getKeywords() {
getParserTokenParaphrases();
return parserKeywordSet;
}
public synchronized static java.util.Map<Integer, String> 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<Integer, String> 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(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'");
parserKeywordSet = new java.util.TreeSet<String>(parserTokenParaphases.values());
}
return parserTokenParaphases;
}
public synchronized static java.util.Set<Integer> 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 StartPatternExpressionRuleContext extends ParserRuleContext {
public PatternExpressionContext patternExpression() {
return getRuleContext(PatternExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public List<AnnotationEnumContext> annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public List<ExpressionDeclContext> expressionDecl() {
return getRuleContexts(ExpressionDeclContext.class);
}
public ExpressionDeclContext expressionDecl(int i) {
return getRuleContext(ExpressionDeclContext.class,i);
}
public StartPatternExpressionRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startPatternExpressionRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStartPatternExpressionRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStartPatternExpressionRule(this);
}
}
public final StartPatternExpressionRuleContext startPatternExpressionRule() throws RecognitionException {
StartPatternExpressionRuleContext _localctx = new StartPatternExpressionRuleContext(_ctx, getState());
enterRule(_localctx, 0, RULE_startPatternExpressionRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(506);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==EXPRESSIONDECL || _la==ATCHAR) {
{
setState(504);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(502);
annotationEnum();
}
break;
case EXPRESSIONDECL:
{
setState(503);
expressionDecl();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(508);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(509);
patternExpression();
setState(510);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StartEPLExpressionRuleContext extends ParserRuleContext {
public EplExpressionContext eplExpression() {
return getRuleContext(EplExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public List<AnnotationEnumContext> annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public List<ExpressionDeclContext> expressionDecl() {
return getRuleContexts(ExpressionDeclContext.class);
}
public ExpressionDeclContext expressionDecl(int i) {
return getRuleContext(ExpressionDeclContext.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, 2, RULE_startEPLExpressionRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(516);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==EXPRESSIONDECL || _la==ATCHAR) {
{
setState(514);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(512);
annotationEnum();
}
break;
case EXPRESSIONDECL:
{
setState(513);
expressionDecl();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(519);
eplExpression();
setState(520);
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 EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.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, 4, RULE_startEventPropertyRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(522);
eventProperty();
setState(523);
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, 6, RULE_startJsonValueRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(525);
jsonvalue();
setState(526);
match(EOF);
}
}
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 array;
public Token name;
public Token alias;
public TerminalNode EXPRESSIONDECL() { return getToken(EsperEPL2GrammarParser.EXPRESSIONDECL, 0); }
public ExpressionDefContext expressionDef() {
return getRuleContext(ExpressionDefContext.class,0);
}
public List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 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 TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 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(528);
match(EXPRESSIONDECL);
setState(530);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(529);
classIdentifier();
}
break;
}
setState(534);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(532);
((ExpressionDeclContext)_localctx).array = match(LBRACK);
setState(533);
match(RBRACK);
}
}
setState(537);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(536);
typeExpressionAnnotation();
}
}
setState(540);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
setState(539);
expressionDialect();
}
break;
}
setState(542);
((ExpressionDeclContext)_localctx).name = match(IDENT);
setState(548);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(543);
match(LPAREN);
setState(545);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(544);
columnList();
}
}
setState(547);
match(RPAREN);
}
}
setState(552);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(550);
((ExpressionDeclContext)_localctx).alias = match(IDENT);
setState(551);
match(FOR);
}
}
setState(554);
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(556);
((ExpressionDialectContext)_localctx).d = match(IDENT);
setState(557);
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(570);
switch (_input.LA(1)) {
case LCURLY:
enterOuterAlt(_localctx, 1);
{
setState(559);
match(LCURLY);
setState(561);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(560);
expressionLambdaDecl();
}
break;
}
setState(563);
expression();
setState(564);
match(RCURLY);
}
break;
case LBRACK:
enterOuterAlt(_localctx, 2);
{
setState(566);
match(LBRACK);
setState(567);
stringconstant();
setState(568);
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 Token i;
public TerminalNode GOES() { return getToken(EsperEPL2GrammarParser.GOES, 0); }
public TerminalNode FOLLOWED_BY() { return getToken(EsperEPL2GrammarParser.FOLLOWED_BY, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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 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(577);
switch (_input.LA(1)) {
case IDENT:
{
setState(572);
((ExpressionLambdaDeclContext)_localctx).i = match(IDENT);
}
break;
case LPAREN:
{
{
setState(573);
match(LPAREN);
setState(574);
columnList();
setState(575);
match(RPAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(579);
_la = _input.LA(1);
if ( !(_la==FOLLOWED_BY || _la==GOES) ) {
_errHandler.recoverInline(this);
} else {
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<TerminalNode> 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(581);
match(ATCHAR);
setState(582);
((ExpressionTypeAnnoContext)_localctx).n = match(IDENT);
{
setState(583);
match(LPAREN);
setState(584);
((ExpressionTypeAnnoContext)_localctx).v = match(IDENT);
setState(585);
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 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);
try {
enterOuterAlt(_localctx, 1);
{
setState(587);
match(ATCHAR);
setState(588);
classIdentifier();
setState(595);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(589);
match(LPAREN);
setState(592);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(590);
elementValuePairsEnum();
}
break;
case 2:
{
setState(591);
elementValueEnum();
}
break;
}
setState(594);
match(RPAREN);
}
break;
}
}
}
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<ElementValuePairEnumContext> elementValuePairEnum() {
return getRuleContexts(ElementValuePairEnumContext.class);
}
public ElementValuePairEnumContext elementValuePairEnum(int i) {
return getRuleContext(ElementValuePairEnumContext.class,i);
}
public List<TerminalNode> 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(597);
elementValuePairEnum();
setState(602);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(598);
match(COMMA);
setState(599);
elementValuePairEnum();
}
}
setState(604);
_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 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(605);
keywordAllowedIdent();
setState(606);
match(EQUALS);
setState(607);
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(614);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(609);
annotationEnum();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(610);
elementValueArrayEnum();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(611);
constant();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(612);
((ElementValueEnumContext)_localctx).v = match(IDENT);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(613);
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 List<ElementValueEnumContext> elementValueEnum() {
return getRuleContexts(ElementValueEnumContext.class);
}
public ElementValueEnumContext elementValueEnum(int i) {
return getRuleContext(ElementValueEnumContext.class,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(616);
match(LCURLY);
setState(625);
_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 - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & ((1L << (LCURLY - 148)) | (1L << (PLUS - 148)) | (1L << (MINUS - 148)) | (1L << (ATCHAR - 148)) | (1L << (TICKED_STRING_LITERAL - 148)) | (1L << (QUOTED_STRING_LITERAL - 148)) | (1L << (STRING_LITERAL - 148)) | (1L << (IDENT - 148)) | (1L << (IntegerLiteral - 148)) | (1L << (FloatingPointLiteral - 148)))) != 0)) {
{
setState(617);
elementValueEnum();
setState(622);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(618);
match(COMMA);
setState(619);
elementValueEnum();
}
}
}
setState(624);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
}
}
}
setState(628);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(627);
match(COMMA);
}
}
setState(630);
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 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(633);
_la = _input.LA(1);
if (_la==CONTEXT) {
{
setState(632);
contextExpr();
}
}
setState(649);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(635);
selectExpr();
}
break;
case 2:
{
setState(636);
createWindowExpr();
}
break;
case 3:
{
setState(637);
createIndexExpr();
}
break;
case 4:
{
setState(638);
createVariableExpr();
}
break;
case 5:
{
setState(639);
createTableExpr();
}
break;
case 6:
{
setState(640);
createSchemaExpr();
}
break;
case 7:
{
setState(641);
createContextExpr();
}
break;
case 8:
{
setState(642);
createExpressionExpr();
}
break;
case 9:
{
setState(643);
onExpr();
}
break;
case 10:
{
setState(644);
updateExpr();
}
break;
case 11:
{
setState(645);
createDataflow();
}
break;
case 12:
{
setState(646);
fafDelete();
}
break;
case 13:
{
setState(647);
fafUpdate();
}
break;
case 14:
{
setState(648);
fafInsert();
}
break;
}
setState(652);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(651);
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(654);
match(CONTEXT);
setState(655);
((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<TerminalNode> 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(659);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(657);
match(INTO);
setState(658);
intoTableExpr();
}
}
setState(663);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(661);
match(INSERT);
setState(662);
insertIntoExpr();
}
}
setState(665);
match(SELECT);
setState(666);
selectClause();
setState(669);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(667);
match(FROM);
setState(668);
fromClause();
}
}
setState(672);
_la = _input.LA(1);
if (_la==MATCH_RECOGNIZE) {
{
setState(671);
matchRecog();
}
}
setState(676);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(674);
match(WHERE);
setState(675);
whereClause();
}
}
setState(681);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(678);
match(GROUP);
setState(679);
match(BY);
setState(680);
groupByListExpr();
}
}
setState(685);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(683);
match(HAVING);
setState(684);
havingClause();
}
}
setState(689);
_la = _input.LA(1);
if (_la==OUTPUT) {
{
setState(687);
match(OUTPUT);
setState(688);
outputLimit();
}
}
setState(694);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(691);
match(ORDER);
setState(692);
match(BY);
setState(693);
orderByListExpr();
}
}
setState(698);
_la = _input.LA(1);
if (_la==ROW_LIMIT_EXPR) {
{
setState(696);
match(ROW_LIMIT_EXPR);
setState(697);
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<OnSelectInsertExprContext> 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(700);
match(ON);
setState(701);
onStreamExpr();
setState(717);
switch (_input.LA(1)) {
case DELETE:
{
setState(702);
onDeleteExpr();
}
break;
case SELECT:
case INSERT:
{
setState(703);
onSelectExpr();
setState(712);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(705);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(704);
onSelectInsertExpr();
}
}
setState(707);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==INSERT );
setState(710);
_la = _input.LA(1);
if (_la==OUTPUT) {
{
setState(709);
outputClauseInsert();
}
}
}
}
}
break;
case SET:
{
setState(714);
onSetExpr();
}
break;
case UPDATE:
{
setState(715);
onUpdateExpr();
}
break;
case MERGE:
{
setState(716);
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 Token i;
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 TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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(721);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(719);
eventFilterExpression();
}
break;
case PATTERN:
{
setState(720);
patternInclusionExpression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(726);
switch (_input.LA(1)) {
case AS:
{
setState(723);
match(AS);
setState(724);
((OnStreamExprContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(725);
((OnStreamExprContext)_localctx).i = match(IDENT);
}
break;
case SELECT:
case INSERT:
case DELETE:
case SET:
case UPDATE:
case MERGE:
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 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(728);
match(UPDATE);
setState(729);
match(ISTREAM);
setState(730);
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 Token i;
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 TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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(732);
classIdentifier();
setState(736);
switch (_input.LA(1)) {
case AS:
{
setState(733);
match(AS);
setState(734);
((UpdateDetailsContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(735);
((UpdateDetailsContext)_localctx).i = match(IDENT);
}
break;
case SET:
break;
default:
throw new NoViableAltException(this);
}
setState(738);
match(SET);
setState(739);
onSetAssignmentList();
setState(742);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(740);
match(WHERE);
setState(741);
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 Token i;
public TerminalNode MERGE() { return getToken(EsperEPL2GrammarParser.MERGE, 0); }
public List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List<MergeItemContext> 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(744);
match(MERGE);
setState(746);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(745);
match(INTO);
}
}
setState(748);
((OnMergeExprContext)_localctx).n = match(IDENT);
setState(752);
switch (_input.LA(1)) {
case AS:
{
setState(749);
match(AS);
setState(750);
((OnMergeExprContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(751);
((OnMergeExprContext)_localctx).i = match(IDENT);
}
break;
case WHERE:
case WHEN:
break;
default:
throw new NoViableAltException(this);
}
setState(756);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(754);
match(WHERE);
setState(755);
whereClause();
}
}
setState(759);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(758);
mergeItem();
}
}
setState(761);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
}
}
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(765);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(763);
mergeMatched();
}
break;
case 2:
{
setState(764);
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<MergeMatchedItemContext> 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(767);
match(WHEN);
setState(768);
match(MATCHED);
setState(771);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(769);
match(AND_EXPR);
setState(770);
expression();
}
}
setState(774);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(773);
mergeMatchedItem();
}
}
setState(776);
_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(778);
match(THEN);
setState(793);
switch (_input.LA(1)) {
case UPDATE:
{
{
setState(779);
((MergeMatchedItemContext)_localctx).u = match(UPDATE);
setState(780);
match(SET);
setState(781);
onSetAssignmentList();
}
setState(785);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(783);
match(WHERE);
setState(784);
whereClause();
}
}
}
break;
case DELETE:
{
setState(787);
((MergeMatchedItemContext)_localctx).d = match(DELETE);
setState(790);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(788);
match(WHERE);
setState(789);
whereClause();
}
}
}
break;
case INSERT:
{
setState(792);
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 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<MergeUnmatchedItemContext> 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, 50, RULE_mergeUnmatched);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(795);
match(WHEN);
setState(796);
match(NOT_EXPR);
setState(797);
match(MATCHED);
setState(800);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(798);
match(AND_EXPR);
setState(799);
expression();
}
}
setState(803);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(802);
mergeUnmatchedItem();
}
}
setState(805);
_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, 52, RULE_mergeUnmatchedItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(807);
match(THEN);
setState(808);
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 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, 54, RULE_mergeInsert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(810);
match(INSERT);
setState(813);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(811);
match(INTO);
setState(812);
classIdentifier();
}
}
setState(819);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(815);
match(LPAREN);
setState(816);
columnList();
setState(817);
match(RPAREN);
}
}
setState(821);
match(SELECT);
setState(822);
selectionList();
setState(825);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(823);
match(WHERE);
setState(824);
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<TerminalNode> 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, 56, RULE_onSelectExpr);
paraphrases.push("on-select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(829);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(827);
match(INSERT);
setState(828);
insertIntoExpr();
}
}
setState(831);
match(SELECT);
setState(836);
_la = _input.LA(1);
if (_la==AND_EXPR || _la==DELETE) {
{
setState(833);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(832);
match(AND_EXPR);
}
}
setState(835);
((OnSelectExprContext)_localctx).d = match(DELETE);
}
}
setState(839);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(838);
match(DISTINCT);
}
}
setState(841);
selectionList();
setState(843);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(842);
onExprFrom();
}
}
setState(847);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(845);
match(WHERE);
setState(846);
whereClause();
}
}
setState(852);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(849);
match(GROUP);
setState(850);
match(BY);
setState(851);
groupByListExpr();
}
}
setState(856);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(854);
match(HAVING);
setState(855);
havingClause();
}
}
setState(861);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(858);
match(ORDER);
setState(859);
match(BY);
setState(860);
orderByListExpr();
}
}
setState(865);
_la = _input.LA(1);
if (_la==ROW_LIMIT_EXPR) {
{
setState(863);
match(ROW_LIMIT_EXPR);
setState(864);
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 Token i;
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 List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 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, 58, RULE_onUpdateExpr);
paraphrases.push("on-update clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(867);
match(UPDATE);
setState(868);
((OnUpdateExprContext)_localctx).n = match(IDENT);
setState(872);
switch (_input.LA(1)) {
case AS:
{
setState(869);
match(AS);
setState(870);
((OnUpdateExprContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(871);
((OnUpdateExprContext)_localctx).i = match(IDENT);
}
break;
case SET:
break;
default:
throw new NoViableAltException(this);
}
setState(874);
match(SET);
setState(875);
onSetAssignmentList();
setState(878);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(876);
match(WHERE);
setState(877);
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, 60, RULE_onSelectInsertExpr);
paraphrases.push("on-select-insert clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(880);
match(INSERT);
setState(881);
insertIntoExpr();
setState(882);
match(SELECT);
setState(883);
selectionList();
setState(885);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(884);
onSelectInsertFromClause();
}
}
setState(889);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(887);
match(WHERE);
setState(888);
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 Token i;
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 TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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, 62, RULE_onSelectInsertFromClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(891);
match(FROM);
setState(892);
propertyExpression();
setState(896);
switch (_input.LA(1)) {
case AS:
{
setState(893);
match(AS);
setState(894);
((OnSelectInsertFromClauseContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(895);
((OnSelectInsertFromClauseContext)_localctx).i = match(IDENT);
}
break;
case EOF:
case WHERE:
case OUTPUT:
case INSERT:
case FOR:
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 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, 64, RULE_outputClauseInsert);
try {
enterOuterAlt(_localctx, 1);
{
setState(898);
match(OUTPUT);
setState(901);
switch (_input.LA(1)) {
case FIRST:
{
setState(899);
((OutputClauseInsertContext)_localctx).f = match(FIRST);
}
break;
case ALL:
{
setState(900);
((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, 66, RULE_onDeleteExpr);
paraphrases.push("on-delete clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(903);
match(DELETE);
setState(904);
onExprFrom();
setState(907);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(905);
match(WHERE);
setState(906);
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, 68, RULE_onSetExpr);
paraphrases.push("on-set clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(909);
match(SET);
setState(910);
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<OnSetAssignmentContext> onSetAssignment() {
return getRuleContexts(OnSetAssignmentContext.class);
}
public OnSetAssignmentContext onSetAssignment(int i) {
return getRuleContext(OnSetAssignmentContext.class,i);
}
public List<TerminalNode> 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, 70, RULE_onSetAssignmentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(912);
onSetAssignment();
setState(917);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(913);
match(COMMA);
setState(914);
onSetAssignment();
}
}
setState(919);
_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 EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.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, 72, RULE_onSetAssignment);
try {
setState(925);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(920);
eventProperty();
setState(921);
match(EQUALS);
setState(922);
expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(924);
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 Token i;
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 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, 74, RULE_onExprFrom);
try {
enterOuterAlt(_localctx, 1);
{
setState(927);
match(FROM);
setState(928);
((OnExprFromContext)_localctx).n = match(IDENT);
setState(932);
switch (_input.LA(1)) {
case AS:
{
setState(929);
match(AS);
setState(930);
((OnExprFromContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(931);
((OnExprFromContext)_localctx).i = match(IDENT);
}
break;
case EOF:
case WHERE:
case GROUP:
case HAVING:
case INSERT:
case ORDER:
case ROW_LIMIT_EXPR:
case FOR:
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 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, 76, RULE_createWindowExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(934);
match(CREATE);
setState(935);
match(WINDOW);
setState(936);
((CreateWindowExprContext)_localctx).i = match(IDENT);
setState(938);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(937);
viewExpressions();
}
}
setState(942);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(940);
((CreateWindowExprContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(941);
((CreateWindowExprContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case AS:
case SELECT:
case EVENTS:
case LPAREN:
case TICKED_STRING_LITERAL:
case IDENT:
break;
default:
throw new NoViableAltException(this);
}
setState(945);
_la = _input.LA(1);
if (_la==AS) {
{
setState(944);
match(AS);
}
}
setState(952);
switch (_input.LA(1)) {
case SELECT:
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(947);
createWindowExprModelAfter();
}
break;
case LPAREN:
{
setState(948);
match(LPAREN);
setState(949);
createColumnList();
setState(950);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(959);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(954);
((CreateWindowExprContext)_localctx).i1 = match(INSERT);
setState(957);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(955);
match(WHERE);
setState(956);
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, 78, RULE_createWindowExprModelAfter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(965);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(961);
match(SELECT);
setState(962);
createSelectionList();
setState(963);
match(FROM);
}
}
setState(967);
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<TerminalNode> 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, 80, RULE_createIndexExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(969);
match(CREATE);
setState(971);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(970);
((CreateIndexExprContext)_localctx).u = match(IDENT);
}
}
setState(973);
match(INDEX);
setState(974);
((CreateIndexExprContext)_localctx).n = match(IDENT);
setState(975);
match(ON);
setState(976);
((CreateIndexExprContext)_localctx).w = match(IDENT);
setState(977);
match(LPAREN);
setState(978);
createIndexColumnList();
setState(979);
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<CreateIndexColumnContext> createIndexColumn() {
return getRuleContexts(CreateIndexColumnContext.class);
}
public CreateIndexColumnContext createIndexColumn(int i) {
return getRuleContext(CreateIndexColumnContext.class,i);
}
public List<TerminalNode> 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, 82, RULE_createIndexColumnList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(981);
createIndexColumn();
setState(986);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(982);
match(COMMA);
setState(983);
createIndexColumn();
}
}
setState(988);
_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<TerminalNode> LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public List<TerminalNode> 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<ExpressionListContext> 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, 84, RULE_createIndexColumn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(995);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(989);
expression();
}
break;
case 2:
{
setState(990);
match(LPAREN);
setState(992);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(991);
((CreateIndexColumnContext)_localctx).i = expressionList();
}
}
setState(994);
match(RPAREN);
}
break;
}
setState(1005);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(997);
((CreateIndexColumnContext)_localctx).t = match(IDENT);
setState(1003);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(998);
match(LPAREN);
setState(1000);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(999);
((CreateIndexColumnContext)_localctx).p = expressionList();
}
}
setState(1002);
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 arr;
public Token p;
public Token n;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode VARIABLE() { return getToken(EsperEPL2GrammarParser.VARIABLE, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 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, 86, RULE_createVariableExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1007);
match(CREATE);
setState(1009);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1008);
((CreateVariableExprContext)_localctx).c = match(IDENT);
}
}
setState(1011);
match(VARIABLE);
setState(1012);
classIdentifier();
setState(1018);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(1013);
((CreateVariableExprContext)_localctx).arr = match(LBRACK);
setState(1015);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1014);
((CreateVariableExprContext)_localctx).p = match(IDENT);
}
}
setState(1017);
match(RBRACK);
}
}
setState(1020);
((CreateVariableExprContext)_localctx).n = match(IDENT);
setState(1023);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(1021);
match(EQUALS);
setState(1022);
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, 88, RULE_createTableExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1025);
match(CREATE);
setState(1026);
match(TABLE);
setState(1027);
((CreateTableExprContext)_localctx).n = match(IDENT);
setState(1029);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1028);
match(AS);
}
}
setState(1031);
match(LPAREN);
setState(1032);
createTableColumnList();
setState(1033);
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<CreateTableColumnContext> createTableColumn() {
return getRuleContexts(CreateTableColumnContext.class);
}
public CreateTableColumnContext createTableColumn(int i) {
return getRuleContext(CreateTableColumnContext.class,i);
}
public List<TerminalNode> 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, 90, RULE_createTableColumnList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1035);
createTableColumn();
setState(1040);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1036);
match(COMMA);
setState(1037);
createTableColumn();
}
}
setState(1042);
_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<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public CreateTableColumnPlainContext createTableColumnPlain() {
return getRuleContext(CreateTableColumnPlainContext.class,0);
}
public BuiltinFuncContext builtinFunc() {
return getRuleContext(BuiltinFuncContext.class,0);
}
public LibFunctionContext libFunction() {
return getRuleContext(LibFunctionContext.class,0);
}
public List<TypeExpressionAnnotationContext> typeExpressionAnnotation() {
return getRuleContexts(TypeExpressionAnnotationContext.class);
}
public TypeExpressionAnnotationContext typeExpressionAnnotation(int i) {
return getRuleContext(TypeExpressionAnnotationContext.class,i);
}
public List<AnnotationEnumContext> 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, 92, RULE_createTableColumn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1043);
((CreateTableColumnContext)_localctx).n = match(IDENT);
setState(1047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(1044);
createTableColumnPlain();
}
break;
case 2:
{
setState(1045);
builtinFunc();
}
break;
case 3:
{
setState(1046);
libFunction();
}
break;
}
setState(1050);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1049);
((CreateTableColumnContext)_localctx).p = match(IDENT);
}
break;
}
setState(1053);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1052);
((CreateTableColumnContext)_localctx).k = match(IDENT);
}
}
setState(1059);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
setState(1057);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
setState(1055);
typeExpressionAnnotation();
}
break;
case 2:
{
setState(1056);
annotationEnum();
}
break;
}
}
setState(1061);
_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 CreateTableColumnPlainContext extends ParserRuleContext {
public Token b;
public Token p;
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CreateTableColumnPlainContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableColumnPlain; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateTableColumnPlain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateTableColumnPlain(this);
}
}
public final CreateTableColumnPlainContext createTableColumnPlain() throws RecognitionException {
CreateTableColumnPlainContext _localctx = new CreateTableColumnPlainContext(_ctx, getState());
enterRule(_localctx, 94, RULE_createTableColumnPlain);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1062);
classIdentifier();
setState(1068);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(1063);
((CreateTableColumnPlainContext)_localctx).b = match(LBRACK);
setState(1065);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1064);
((CreateTableColumnPlainContext)_localctx).p = match(IDENT);
}
}
setState(1067);
match(RBRACK);
}
}
}
}
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<CreateColumnListElementContext> createColumnListElement() {
return getRuleContexts(CreateColumnListElementContext.class);
}
public CreateColumnListElementContext createColumnListElement(int i) {
return getRuleContext(CreateColumnListElementContext.class,i);
}
public List<TerminalNode> 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(1070);
createColumnListElement();
setState(1075);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1071);
match(COMMA);
setState(1072);
createColumnListElement();
}
}
setState(1077);
_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 Token b;
public Token p;
public List<ClassIdentifierContext> classIdentifier() {
return getRuleContexts(ClassIdentifierContext.class);
}
public ClassIdentifierContext classIdentifier(int i) {
return getRuleContext(ClassIdentifierContext.class,i);
}
public TerminalNode VALUE_NULL() { return getToken(EsperEPL2GrammarParser.VALUE_NULL, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1078);
classIdentifier();
setState(1088);
switch (_input.LA(1)) {
case VALUE_NULL:
{
setState(1079);
match(VALUE_NULL);
}
break;
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
{
setState(1080);
classIdentifier();
setState(1086);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(1081);
((CreateColumnListElementContext)_localctx).b = match(LBRACK);
setState(1083);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1082);
((CreateColumnListElementContext)_localctx).p = match(IDENT);
}
}
setState(1085);
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 CreateSelectionListContext extends ParserRuleContext {
public List<CreateSelectionListElementContext> createSelectionListElement() {
return getRuleContexts(CreateSelectionListElementContext.class);
}
public CreateSelectionListElementContext createSelectionListElement(int i) {
return getRuleContext(CreateSelectionListElementContext.class,i);
}
public List<TerminalNode> 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(1090);
createSelectionListElement();
setState(1095);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1091);
match(COMMA);
setState(1092);
createSelectionListElement();
}
}
setState(1097);
_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 EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.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(1108);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1098);
((CreateSelectionListElementContext)_localctx).s = match(STAR);
}
break;
case WINDOW:
case ESCAPE:
case EVERY_EXPR:
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 VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case DEFINE:
case PARTITION:
case MATCHES:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case CONTEXT:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1099);
eventProperty();
setState(1102);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1100);
match(AS);
setState(1101);
((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(1104);
constant();
setState(1105);
match(AS);
setState(1106);
((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(1110);
match(CREATE);
setState(1112);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1111);
((CreateSchemaExprContext)_localctx).keyword = match(IDENT);
}
}
setState(1114);
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<CreateSchemaQualContext> 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(1116);
match(SCHEMA);
setState(1117);
((CreateSchemaDefContext)_localctx).name = match(IDENT);
setState(1119);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1118);
match(AS);
}
}
setState(1127);
switch (_input.LA(1)) {
case EVENTS:
case STAR:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1121);
variantList();
}
break;
case LPAREN:
{
setState(1122);
match(LPAREN);
setState(1124);
_la = _input.LA(1);
if (_la==EVENTS || _la==TICKED_STRING_LITERAL || _la==IDENT) {
{
setState(1123);
createColumnList();
}
}
setState(1126);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1132);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENT) {
{
{
setState(1129);
createSchemaQual();
}
}
setState(1134);
_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 Token i;
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 TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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(1135);
match(DELETE);
setState(1136);
match(FROM);
setState(1137);
classIdentifier();
setState(1141);
switch (_input.LA(1)) {
case AS:
{
setState(1138);
match(AS);
setState(1139);
((FafDeleteContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(1140);
((FafDeleteContext)_localctx).i = match(IDENT);
}
break;
case EOF:
case WHERE:
case FOR:
break;
default:
throw new NoViableAltException(this);
}
setState(1145);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1143);
match(WHERE);
setState(1144);
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(1147);
match(UPDATE);
setState(1148);
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 TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
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);
try {
enterOuterAlt(_localctx, 1);
{
setState(1150);
match(INSERT);
setState(1151);
insertIntoExpr();
setState(1152);
match(VALUES);
setState(1153);
match(LPAREN);
setState(1154);
expressionList();
setState(1155);
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, 114, RULE_createDataflow);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1157);
match(CREATE);
setState(1158);
match(DATAFLOW);
setState(1159);
((CreateDataflowContext)_localctx).name = match(IDENT);
setState(1161);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1160);
match(AS);
}
}
setState(1163);
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<GopContext> 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, 116, RULE_gopList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1165);
gop();
setState(1169);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CREATE || _la==SELECT || _la==ATCHAR || _la==IDENT) {
{
{
setState(1166);
gop();
}
}
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 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<AnnotationEnumContext> 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, 118, RULE_gop);
int _la;
try {
setState(1199);
switch (_input.LA(1)) {
case SELECT:
case ATCHAR:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(1175);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
{
setState(1172);
annotationEnum();
}
}
setState(1177);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1180);
switch (_input.LA(1)) {
case IDENT:
{
setState(1178);
((GopContext)_localctx).opName = match(IDENT);
}
break;
case SELECT:
{
setState(1179);
((GopContext)_localctx).s = match(SELECT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1183);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1182);
gopParams();
}
}
setState(1186);
_la = _input.LA(1);
if (_la==FOLLOWED_BY) {
{
setState(1185);
gopOut();
}
}
setState(1188);
match(LCURLY);
setState(1190);
_la = _input.LA(1);
if (_la==SELECT || _la==IDENT) {
{
setState(1189);
gopDetail();
}
}
setState(1193);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1192);
match(COMMA);
}
}
setState(1195);
match(RCURLY);
}
break;
case CREATE:
enterOuterAlt(_localctx, 2);
{
setState(1196);
createSchemaExpr();
setState(1197);
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, 120, RULE_gopParams);
try {
enterOuterAlt(_localctx, 1);
{
setState(1201);
match(LPAREN);
setState(1202);
gopParamsItemList();
setState(1203);
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<GopParamsItemContext> gopParamsItem() {
return getRuleContexts(GopParamsItemContext.class);
}
public GopParamsItemContext gopParamsItem(int i) {
return getRuleContext(GopParamsItemContext.class,i);
}
public List<TerminalNode> 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, 122, RULE_gopParamsItemList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1205);
gopParamsItem();
setState(1210);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1206);
match(COMMA);
setState(1207);
gopParamsItem();
}
}
setState(1212);
_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, 124, RULE_gopParamsItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1215);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1213);
((GopParamsItemContext)_localctx).n = classIdentifier();
}
break;
case LPAREN:
{
setState(1214);
gopParamsItemMany();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1218);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1217);
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<ClassIdentifierContext> 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, 126, RULE_gopParamsItemMany);
try {
enterOuterAlt(_localctx, 1);
{
setState(1220);
match(LPAREN);
setState(1221);
classIdentifier();
{
setState(1222);
match(COMMA);
setState(1223);
classIdentifier();
}
setState(1225);
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, 128, RULE_gopParamsItemAs);
try {
enterOuterAlt(_localctx, 1);
{
setState(1227);
match(AS);
setState(1228);
((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<GopOutItemContext> gopOutItem() {
return getRuleContexts(GopOutItemContext.class);
}
public GopOutItemContext gopOutItem(int i) {
return getRuleContext(GopOutItemContext.class,i);
}
public List<TerminalNode> 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, 130, RULE_gopOut);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1230);
match(FOLLOWED_BY);
setState(1231);
gopOutItem();
setState(1236);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1232);
match(COMMA);
setState(1233);
gopOutItem();
}
}
setState(1238);
_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, 132, RULE_gopOutItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1239);
((GopOutItemContext)_localctx).n = classIdentifier();
setState(1241);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1240);
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<GopOutTypeParamContext> 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<TerminalNode> 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, 134, RULE_gopOutTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1243);
match(LT);
setState(1244);
gopOutTypeParam();
setState(1249);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1245);
match(COMMA);
setState(1246);
gopOutTypeParam();
}
}
setState(1251);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1252);
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, 136, RULE_gopOutTypeParam);
try {
enterOuterAlt(_localctx, 1);
{
setState(1256);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1254);
gopOutTypeItem();
}
break;
case QUESTION:
{
setState(1255);
((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, 138, RULE_gopOutTypeItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1258);
classIdentifier();
setState(1260);
_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 GopDetailContext extends ParserRuleContext {
public List<GopConfigContext> gopConfig() {
return getRuleContexts(GopConfigContext.class);
}
public GopConfigContext gopConfig(int i) {
return getRuleContext(GopConfigContext.class,i);
}
public List<TerminalNode> 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, 140, RULE_gopDetail);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1262);
gopConfig();
setState(1267);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,135,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1263);
match(COMMA);
setState(1264);
gopConfig();
}
}
}
setState(1269);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,135,_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, 142, RULE_gopConfig);
int _la;
try {
setState(1283);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(1270);
match(SELECT);
setState(1271);
_la = _input.LA(1);
if ( !(_la==EQUALS || _la==COLON) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1272);
match(LPAREN);
setState(1273);
selectExpr();
setState(1274);
match(RPAREN);
}
break;
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1276);
((GopConfigContext)_localctx).n = match(IDENT);
setState(1277);
_la = _input.LA(1);
if ( !(_la==EQUALS || _la==COLON) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1281);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
{
setState(1278);
expression();
}
break;
case 2:
{
setState(1279);
jsonobject();
}
break;
case 3:
{
setState(1280);
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, 144, RULE_createContextExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1285);
match(CREATE);
setState(1286);
match(CONTEXT);
setState(1287);
((CreateContextExprContext)_localctx).name = match(IDENT);
setState(1289);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1288);
match(AS);
}
}
setState(1291);
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, 146, RULE_createExpressionExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1293);
match(CREATE);
setState(1294);
expressionDecl();
}
}
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<ContextContextNestedContext> contextContextNested() {
return getRuleContexts(ContextContextNestedContext.class);
}
public ContextContextNestedContext contextContextNested(int i) {
return getRuleContext(ContextContextNestedContext.class,i);
}
public List<TerminalNode> 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, 148, RULE_createContextDetail);
int _la;
try {
setState(1307);
switch (_input.LA(1)) {
case COALESCE:
case GROUP:
case PARTITION:
case START:
case INITIATED:
enterOuterAlt(_localctx, 1);
{
setState(1296);
createContextChoice();
}
break;
case CONTEXT:
enterOuterAlt(_localctx, 2);
{
setState(1297);
contextContextNested();
setState(1298);
match(COMMA);
setState(1299);
contextContextNested();
setState(1304);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1300);
match(COMMA);
setState(1301);
contextContextNested();
}
}
setState(1306);
_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, 150, RULE_contextContextNested);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1309);
match(CONTEXT);
setState(1310);
((ContextContextNestedContext)_localctx).name = match(IDENT);
setState(1312);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1311);
match(AS);
}
}
setState(1314);
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<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List<CreateContextRangePointContext> 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<TerminalNode> 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<CreateContextPartitionItemContext> createContextPartitionItem() {
return getRuleContexts(CreateContextPartitionItemContext.class);
}
public CreateContextPartitionItemContext createContextPartitionItem(int i) {
return getRuleContext(CreateContextPartitionItemContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List<CreateContextGroupItemContext> 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<CreateContextCoalesceItemContext> 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, 152, RULE_createContextChoice);
int _la;
try {
int _alt;
setState(1386);
switch (_input.LA(1)) {
case START:
enterOuterAlt(_localctx, 1);
{
setState(1316);
match(START);
setState(1320);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(1317);
match(ATCHAR);
setState(1318);
((CreateContextChoiceContext)_localctx).i = match(IDENT);
}
break;
case EVENTS:
case PATTERN:
case AFTER:
case LPAREN:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1319);
((CreateContextChoiceContext)_localctx).r1 = createContextRangePoint();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1324);
_la = _input.LA(1);
if (_la==END) {
{
setState(1322);
match(END);
setState(1323);
((CreateContextChoiceContext)_localctx).r2 = createContextRangePoint();
}
}
}
break;
case INITIATED:
enterOuterAlt(_localctx, 2);
{
setState(1326);
match(INITIATED);
setState(1328);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1327);
match(BY);
}
}
setState(1331);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1330);
createContextDistinct();
}
}
setState(1336);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1333);
match(ATCHAR);
setState(1334);
((CreateContextChoiceContext)_localctx).i = match(IDENT);
setState(1335);
match(AND_EXPR);
}
}
setState(1338);
((CreateContextChoiceContext)_localctx).r1 = createContextRangePoint();
setState(1344);
_la = _input.LA(1);
if (_la==TERMINATED) {
{
setState(1339);
match(TERMINATED);
setState(1341);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1340);
match(BY);
}
}
setState(1343);
((CreateContextChoiceContext)_localctx).r2 = createContextRangePoint();
}
}
}
break;
case PARTITION:
enterOuterAlt(_localctx, 3);
{
setState(1346);
match(PARTITION);
setState(1348);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1347);
match(BY);
}
}
setState(1350);
createContextPartitionItem();
setState(1355);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1351);
match(COMMA);
setState(1352);
createContextPartitionItem();
}
}
}
setState(1357);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
}
}
break;
case GROUP:
enterOuterAlt(_localctx, 4);
{
setState(1358);
createContextGroupItem();
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1359);
match(COMMA);
setState(1360);
createContextGroupItem();
}
}
setState(1365);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1366);
match(FROM);
setState(1367);
eventFilterExpression();
}
break;
case COALESCE:
enterOuterAlt(_localctx, 5);
{
setState(1369);
match(COALESCE);
setState(1371);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1370);
match(BY);
}
}
setState(1373);
createContextCoalesceItem();
setState(1378);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1374);
match(COMMA);
setState(1375);
createContextCoalesceItem();
}
}
setState(1380);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1381);
((CreateContextChoiceContext)_localctx).g = match(IDENT);
setState(1382);
number();
setState(1384);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1383);
((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, 154, RULE_createContextDistinct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1388);
match(DISTINCT);
setState(1389);
match(LPAREN);
setState(1391);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(1390);
expressionList();
}
}
setState(1393);
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 TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CrontabLimitParameterSetContext crontabLimitParameterSet() {
return getRuleContext(CrontabLimitParameterSetContext.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, 156, RULE_createContextRangePoint);
int _la;
try {
setState(1404);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(1395);
createContextFilter();
}
break;
case PATTERN:
enterOuterAlt(_localctx, 2);
{
setState(1396);
patternInclusionExpression();
setState(1399);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1397);
match(ATCHAR);
setState(1398);
((CreateContextRangePointContext)_localctx).i = match(IDENT);
}
}
}
break;
case LPAREN:
enterOuterAlt(_localctx, 3);
{
setState(1401);
crontabLimitParameterSet();
}
break;
case AFTER:
enterOuterAlt(_localctx, 4);
{
setState(1402);
match(AFTER);
setState(1403);
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, 158, RULE_createContextFilter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1406);
eventFilterExpression();
setState(1411);
_la = _input.LA(1);
if (_la==AS || _la==IDENT) {
{
setState(1408);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1407);
match(AS);
}
}
setState(1410);
((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<EventPropertyContext> eventProperty() {
return getRuleContexts(EventPropertyContext.class);
}
public EventPropertyContext eventProperty(int i) {
return getRuleContext(EventPropertyContext.class,i);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public List<TerminalNode> AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public List<TerminalNode> COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
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, 160, RULE_createContextPartitionItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1413);
eventProperty();
setState(1418);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR || _la==COMMA) {
{
{
setState(1414);
_la = _input.LA(1);
if ( !(_la==AND_EXPR || _la==COMMA) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1415);
eventProperty();
}
}
setState(1420);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1421);
match(FROM);
setState(1422);
eventFilterExpression();
}
}
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 LibFunctionNoClassContext libFunctionNoClass() {
return getRuleContext(LibFunctionNoClassContext.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, 162, RULE_createContextCoalesceItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1424);
libFunctionNoClass();
setState(1425);
match(FROM);
setState(1426);
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, 164, RULE_createContextGroupItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1428);
match(GROUP);
setState(1430);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1429);
match(BY);
}
}
setState(1432);
expression();
setState(1433);
match(AS);
setState(1434);
((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 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, 166, RULE_createSchemaQual);
try {
enterOuterAlt(_localctx, 1);
{
setState(1436);
((CreateSchemaQualContext)_localctx).i = match(IDENT);
setState(1437);
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<VariantListElementContext> variantListElement() {
return getRuleContexts(VariantListElementContext.class);
}
public VariantListElementContext variantListElement(int i) {
return getRuleContext(VariantListElementContext.class,i);
}
public List<TerminalNode> 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, 168, RULE_variantList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1439);
variantListElement();
setState(1444);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1440);
match(COMMA);
setState(1441);
variantListElement();
}
}
}
setState(1446);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,163,_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 ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.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, 170, RULE_variantListElement);
try {
setState(1449);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1447);
match(STAR);
}
break;
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1448);
classIdentifier();
}
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, 172, RULE_intoTableExpr);
paraphrases.push("into-table clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1451);
match(TABLE);
setState(1452);
((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 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, 174, RULE_insertIntoExpr);
paraphrases.push("insert-into clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1457);
switch (_input.LA(1)) {
case ISTREAM:
{
setState(1454);
((InsertIntoExprContext)_localctx).i = match(ISTREAM);
}
break;
case RSTREAM:
{
setState(1455);
((InsertIntoExprContext)_localctx).r = match(RSTREAM);
}
break;
case IRSTREAM:
{
setState(1456);
((InsertIntoExprContext)_localctx).ir = match(IRSTREAM);
}
break;
case INTO:
break;
default:
throw new NoViableAltException(this);
}
setState(1459);
match(INTO);
setState(1460);
classIdentifier();
setState(1466);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1461);
match(LPAREN);
setState(1463);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1462);
columnList();
}
}
setState(1465);
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 ColumnListContext extends ParserRuleContext {
public List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List<TerminalNode> 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, 176, RULE_columnList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1468);
match(IDENT);
setState(1473);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1469);
match(COMMA);
setState(1470);
match(IDENT);
}
}
}
setState(1475);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
}
}
}
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, 178, RULE_fromClause);
paraphrases.push("from clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1476);
streamExpression();
setState(1479);
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(1477);
regularJoin();
}
break;
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
{
setState(1478);
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<TerminalNode> COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List<StreamExpressionContext> 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, 180, RULE_regularJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1485);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1481);
match(COMMA);
setState(1482);
streamExpression();
}
}
setState(1487);
_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<OuterJoinContext> 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, 182, RULE_outerJoinList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1488);
outerJoin();
setState(1492);
_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(1489);
outerJoin();
}
}
setState(1494);
_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, 184, RULE_outerJoin);
paraphrases.push("outer join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1504);
switch (_input.LA(1)) {
case JOIN:
case LEFT:
case RIGHT:
case FULL:
{
setState(1501);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEFT) | (1L << RIGHT) | (1L << FULL))) != 0)) {
{
setState(1498);
switch (_input.LA(1)) {
case LEFT:
{
setState(1495);
((OuterJoinContext)_localctx).tl = match(LEFT);
}
break;
case RIGHT:
{
setState(1496);
((OuterJoinContext)_localctx).tr = match(RIGHT);
}
break;
case FULL:
{
setState(1497);
((OuterJoinContext)_localctx).tf = match(FULL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1500);
match(OUTER);
}
}
}
break;
case INNER:
{
{
setState(1503);
((OuterJoinContext)_localctx).i = match(INNER);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1506);
match(JOIN);
setState(1507);
streamExpression();
setState(1509);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1508);
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<OuterJoinIdentPairContext> outerJoinIdentPair() {
return getRuleContexts(OuterJoinIdentPairContext.class);
}
public OuterJoinIdentPairContext outerJoinIdentPair(int i) {
return getRuleContext(OuterJoinIdentPairContext.class,i);
}
public List<TerminalNode> 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, 186, RULE_outerJoinIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1511);
match(ON);
setState(1512);
outerJoinIdentPair();
setState(1517);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR) {
{
{
setState(1513);
match(AND_EXPR);
setState(1514);
outerJoinIdentPair();
}
}
setState(1519);
_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<EventPropertyContext> eventProperty() {
return getRuleContexts(EventPropertyContext.class);
}
public EventPropertyContext eventProperty(int i) {
return getRuleContext(EventPropertyContext.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, 188, RULE_outerJoinIdentPair);
try {
enterOuterAlt(_localctx, 1);
{
setState(1520);
eventProperty();
setState(1521);
match(EQUALS);
setState(1522);
eventProperty();
}
}
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, 190, RULE_whereClause);
paraphrases.push("where clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1524);
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, 192, RULE_selectClause);
paraphrases.push("select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1529);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
case 1:
{
setState(1526);
((SelectClauseContext)_localctx).s = match(RSTREAM);
}
break;
case 2:
{
setState(1527);
((SelectClauseContext)_localctx).s = match(ISTREAM);
}
break;
case 3:
{
setState(1528);
((SelectClauseContext)_localctx).s = match(IRSTREAM);
}
break;
}
setState(1532);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1531);
((SelectClauseContext)_localctx).d = match(DISTINCT);
}
}
setState(1534);
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<SelectionListElementContext> selectionListElement() {
return getRuleContexts(SelectionListElementContext.class);
}
public SelectionListElementContext selectionListElement(int i) {
return getRuleContext(SelectionListElementContext.class,i);
}
public List<TerminalNode> 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, 194, RULE_selectionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1536);
selectionListElement();
setState(1541);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1537);
match(COMMA);
setState(1538);
selectionListElement();
}
}
setState(1543);
_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, 196, RULE_selectionListElement);
try {
setState(1547);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1544);
((SelectionListElementContext)_localctx).s = match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1545);
streamSelector();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1546);
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, 198, RULE_selectionListElementExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1549);
expression();
setState(1551);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1550);
selectionListElementAnno();
}
}
setState(1557);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
case 1:
{
setState(1554);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1553);
match(AS);
}
}
setState(1556);
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, 200, RULE_selectionListElementAnno);
try {
enterOuterAlt(_localctx, 1);
{
setState(1559);
match(ATCHAR);
setState(1560);
((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<TerminalNode> 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, 202, RULE_streamSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1562);
((StreamSelectorContext)_localctx).s = match(IDENT);
setState(1563);
match(DOT);
setState(1564);
match(STAR);
setState(1567);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1565);
match(AS);
setState(1566);
((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 i;
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 TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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, 204, RULE_streamExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
{
setState(1569);
eventFilterExpression();
}
break;
case 2:
{
setState(1570);
patternInclusionExpression();
}
break;
case 3:
{
setState(1571);
databaseJoinExpression();
}
break;
case 4:
{
setState(1572);
methodJoinExpression();
}
break;
}
setState(1576);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(1575);
viewExpressions();
}
}
setState(1581);
switch (_input.LA(1)) {
case AS:
{
setState(1578);
match(AS);
setState(1579);
((StreamExpressionContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(1580);
((StreamExpressionContext)_localctx).i = match(IDENT);
}
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:
throw new NoViableAltException(this);
}
setState(1584);
_la = _input.LA(1);
if (_la==UNIDIRECTIONAL) {
{
setState(1583);
((StreamExpressionContext)_localctx).u = match(UNIDIRECTIONAL);
}
}
setState(1588);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(1586);
((StreamExpressionContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(1587);
((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:
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 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, 206, RULE_forExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1590);
match(FOR);
setState(1591);
((ForExprContext)_localctx).i = match(IDENT);
setState(1597);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1592);
match(LPAREN);
setState(1594);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(1593);
expressionList();
}
}
setState(1596);
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<AnnotationEnumContext> 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, 208, RULE_patternInclusionExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1599);
match(PATTERN);
setState(1603);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
{
setState(1600);
annotationEnum();
}
}
setState(1605);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1606);
match(LBRACK);
setState(1607);
patternExpression();
setState(1608);
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<TerminalNode> STRING_LITERAL() { return getTokens(EsperEPL2GrammarParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(EsperEPL2GrammarParser.STRING_LITERAL, i);
}
public List<TerminalNode> 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, 210, RULE_databaseJoinExpression);
paraphrases.push("relational data join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1610);
match(SQL);
setState(1611);
match(COLON);
setState(1612);
((DatabaseJoinExpressionContext)_localctx).i = match(IDENT);
setState(1613);
match(LBRACK);
setState(1616);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(1614);
((DatabaseJoinExpressionContext)_localctx).s = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(1615);
((DatabaseJoinExpressionContext)_localctx).s = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1623);
_la = _input.LA(1);
if (_la==METADATASQL) {
{
setState(1618);
match(METADATASQL);
setState(1621);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(1619);
((DatabaseJoinExpressionContext)_localctx).s2 = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(1620);
((DatabaseJoinExpressionContext)_localctx).s2 = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(1625);
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, 212, RULE_methodJoinExpression);
paraphrases.push("method invocation join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1627);
((MethodJoinExpressionContext)_localctx).i = match(IDENT);
setState(1628);
match(COLON);
setState(1629);
classIdentifier();
setState(1635);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1630);
match(LPAREN);
setState(1632);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(1631);
expressionList();
}
}
setState(1634);
match(RPAREN);
}
}
setState(1638);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1637);
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<TerminalNode> DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public List<ViewExpressionWNamespaceContext> viewExpressionWNamespace() {
return getRuleContexts(ViewExpressionWNamespaceContext.class);
}
public ViewExpressionWNamespaceContext viewExpressionWNamespace(int i) {
return getRuleContext(ViewExpressionWNamespaceContext.class,i);
}
public List<TerminalNode> HASHCHAR() { return getTokens(EsperEPL2GrammarParser.HASHCHAR); }
public TerminalNode HASHCHAR(int i) {
return getToken(EsperEPL2GrammarParser.HASHCHAR, i);
}
public List<ViewExpressionOptNamespaceContext> 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, 214, RULE_viewExpressions);
paraphrases.push("view specifications");
int _la;
try {
setState(1658);
switch (_input.LA(1)) {
case DOT:
enterOuterAlt(_localctx, 1);
{
{
setState(1640);
match(DOT);
setState(1641);
viewExpressionWNamespace();
setState(1646);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1642);
match(DOT);
setState(1643);
viewExpressionWNamespace();
}
}
setState(1648);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case HASHCHAR:
enterOuterAlt(_localctx, 2);
{
{
setState(1649);
match(HASHCHAR);
setState(1650);
viewExpressionOptNamespace();
setState(1655);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==HASHCHAR) {
{
{
setState(1651);
match(HASHCHAR);
setState(1652);
viewExpressionOptNamespace();
}
}
setState(1657);
_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, 216, RULE_viewExpressionWNamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1660);
((ViewExpressionWNamespaceContext)_localctx).ns = match(IDENT);
setState(1661);
match(COLON);
setState(1662);
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, 218, RULE_viewExpressionOptNamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1666);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
{
setState(1664);
((ViewExpressionOptNamespaceContext)_localctx).ns = match(IDENT);
setState(1665);
match(COLON);
}
break;
}
setState(1668);
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, 220, RULE_viewWParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1672);
switch (_input.LA(1)) {
case IDENT:
{
setState(1670);
((ViewWParametersContext)_localctx).i = match(IDENT);
}
break;
case MERGE:
{
setState(1671);
((ViewWParametersContext)_localctx).m = match(MERGE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1679);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) {
case 1:
{
setState(1674);
match(LPAREN);
setState(1676);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(1675);
expressionWithTimeList();
}
}
setState(1678);
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<GroupByListChoiceContext> groupByListChoice() {
return getRuleContexts(GroupByListChoiceContext.class);
}
public GroupByListChoiceContext groupByListChoice(int i) {
return getRuleContext(GroupByListChoiceContext.class,i);
}
public List<TerminalNode> 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, 222, RULE_groupByListExpr);
paraphrases.push("group-by clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1681);
groupByListChoice();
setState(1686);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1682);
match(COMMA);
setState(1683);
groupByListChoice();
}
}
setState(1688);
_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, 224, RULE_groupByListChoice);
try {
setState(1692);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1689);
((GroupByListChoiceContext)_localctx).e1 = expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1690);
groupByCubeOrRollup();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1691);
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<GroupByCombinableExprContext> 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<TerminalNode> 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, 226, RULE_groupByCubeOrRollup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1694);
_la = _input.LA(1);
if ( !(_la==CUBE || _la==ROLLUP) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1695);
match(LPAREN);
setState(1696);
groupByCombinableExpr();
setState(1701);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1697);
match(COMMA);
setState(1698);
groupByCombinableExpr();
}
}
setState(1703);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1704);
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<GroupBySetsChoiceContext> 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<TerminalNode> 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, 228, RULE_groupByGroupingSets);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1706);
match(GROUPING);
setState(1707);
match(SETS);
setState(1708);
match(LPAREN);
setState(1709);
groupBySetsChoice();
setState(1714);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1710);
match(COMMA);
setState(1711);
groupBySetsChoice();
}
}
setState(1716);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1717);
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, 230, RULE_groupBySetsChoice);
try {
setState(1721);
switch (_input.LA(1)) {
case CUBE:
case ROLLUP:
enterOuterAlt(_localctx, 1);
{
setState(1719);
groupByCubeOrRollup();
}
break;
case WINDOW:
case ESCAPE:
case NOT_EXPR:
case EVERY_EXPR:
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 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 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(1720);
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<ExpressionContext> 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<TerminalNode> 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, 232, RULE_groupByCombinableExpr);
int _la;
try {
setState(1736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1723);
((GroupByCombinableExprContext)_localctx).e1 = expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1724);
match(LPAREN);
setState(1733);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(1725);
expression();
setState(1730);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1726);
match(COMMA);
setState(1727);
expression();
}
}
setState(1732);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1735);
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<OrderByListElementContext> orderByListElement() {
return getRuleContexts(OrderByListElementContext.class);
}
public OrderByListElementContext orderByListElement(int i) {
return getRuleContext(OrderByListElementContext.class,i);
}
public List<TerminalNode> 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, 234, RULE_orderByListExpr);
paraphrases.push("order by clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1738);
orderByListElement();
setState(1743);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1739);
match(COMMA);
setState(1740);
orderByListElement();
}
}
setState(1745);
_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, 236, RULE_orderByListElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1746);
expression();
setState(1749);
switch (_input.LA(1)) {
case ASC:
{
setState(1747);
((OrderByListElementContext)_localctx).a = match(ASC);
}
break;
case DESC:
{
setState(1748);
((OrderByListElementContext)_localctx).d = match(DESC);
}
break;
case EOF:
case INSERT:
case ROW_LIMIT_EXPR:
case FOR:
case RPAREN:
case 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 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, 238, RULE_havingClause);
paraphrases.push("having clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1751);
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, 240, RULE_outputLimit);
paraphrases.push("output rate clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1754);
_la = _input.LA(1);
if (_la==AFTER) {
{
setState(1753);
outputLimitAfter();
}
}
setState(1760);
switch (_input.LA(1)) {
case ALL:
{
setState(1756);
((OutputLimitContext)_localctx).k = match(ALL);
}
break;
case FIRST:
{
setState(1757);
((OutputLimitContext)_localctx).k = match(FIRST);
}
break;
case LAST:
{
setState(1758);
((OutputLimitContext)_localctx).k = match(LAST);
}
break;
case SNAPSHOT:
{
setState(1759);
((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:
throw new NoViableAltException(this);
}
setState(1790);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,223,_ctx) ) {
case 1:
{
{
setState(1762);
((OutputLimitContext)_localctx).ev = match(EVERY_EXPR);
setState(1769);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
case 1:
{
setState(1763);
timePeriod();
}
break;
case 2:
{
setState(1766);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1764);
number();
}
break;
case IDENT:
{
setState(1765);
((OutputLimitContext)_localctx).i = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
{
setState(1768);
((OutputLimitContext)_localctx).e = match(EVENTS);
}
}
break;
}
}
}
break;
case 2:
{
{
setState(1771);
((OutputLimitContext)_localctx).at = match(AT);
setState(1772);
crontabLimitParameterSet();
}
}
break;
case 3:
{
{
setState(1773);
((OutputLimitContext)_localctx).wh = match(WHEN);
setState(1774);
expression();
setState(1777);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1775);
match(THEN);
setState(1776);
onSetExpr();
}
}
}
}
break;
case 4:
{
{
setState(1779);
((OutputLimitContext)_localctx).t = match(WHEN);
setState(1780);
match(TERMINATED);
setState(1783);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) {
case 1:
{
setState(1781);
match(AND_EXPR);
setState(1782);
expression();
}
break;
}
setState(1787);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1785);
match(THEN);
setState(1786);
onSetExpr();
}
}
}
}
break;
case 5:
{
}
break;
}
setState(1793);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(1792);
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<TerminalNode> 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, 242, RULE_outputLimitAndTerm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1795);
match(AND_EXPR);
setState(1796);
match(WHEN);
setState(1797);
match(TERMINATED);
setState(1800);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(1798);
match(AND_EXPR);
setState(1799);
expression();
}
}
setState(1804);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1802);
match(THEN);
setState(1803);
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, 244, RULE_outputLimitAfter);
try {
enterOuterAlt(_localctx, 1);
{
setState(1806);
((OutputLimitAfterContext)_localctx).a = match(AFTER);
setState(1811);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
case 1:
{
setState(1807);
timePeriod();
}
break;
case 2:
{
setState(1808);
number();
setState(1809);
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<NumberconstantContext> numberconstant() {
return getRuleContexts(NumberconstantContext.class);
}
public NumberconstantContext numberconstant(int i) {
return getRuleContext(NumberconstantContext.class,i);
}
public List<TerminalNode> 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, 246, RULE_rowLimit);
paraphrases.push("row limit clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1815);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1813);
((RowLimitContext)_localctx).n1 = numberconstant();
}
break;
case IDENT:
{
setState(1814);
((RowLimitContext)_localctx).i1 = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1825);
_la = _input.LA(1);
if (_la==OFFSET || _la==COMMA) {
{
setState(1819);
switch (_input.LA(1)) {
case COMMA:
{
setState(1817);
((RowLimitContext)_localctx).c = match(COMMA);
}
break;
case OFFSET:
{
setState(1818);
((RowLimitContext)_localctx).o = match(OFFSET);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1823);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1821);
((RowLimitContext)_localctx).n2 = numberconstant();
}
break;
case IDENT:
{
setState(1822);
((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 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, 248, RULE_crontabLimitParameterSet);
try {
enterOuterAlt(_localctx, 1);
{
setState(1827);
match(LPAREN);
setState(1828);
expressionWithTimeList();
setState(1829);
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<ExpressionContext> 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, 250, RULE_whenClause);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1831);
match(WHEN);
setState(1832);
expression();
setState(1833);
match(THEN);
setState(1834);
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, 252, RULE_elseClause);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1836);
match(ELSE);
setState(1837);
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, 254, RULE_matchRecog);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1839);
match(MATCH_RECOGNIZE);
setState(1840);
match(LPAREN);
setState(1842);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1841);
matchRecogPartitionBy();
}
}
setState(1844);
matchRecogMeasures();
setState(1846);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(1845);
matchRecogMatchesSelection();
}
}
setState(1849);
_la = _input.LA(1);
if (_la==AFTER) {
{
setState(1848);
matchRecogMatchesAfterSkip();
}
}
setState(1851);
matchRecogPattern();
setState(1853);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1852);
matchRecogMatchesInterval();
}
}
setState(1856);
_la = _input.LA(1);
if (_la==DEFINE) {
{
setState(1855);
matchRecogDefine();
}
}
setState(1858);
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<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> 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, 256, RULE_matchRecogPartitionBy);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1860);
match(PARTITION);
setState(1861);
match(BY);
setState(1862);
expression();
setState(1867);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1863);
match(COMMA);
setState(1864);
expression();
}
}
setState(1869);
_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<MatchRecogMeasureItemContext> matchRecogMeasureItem() {
return getRuleContexts(MatchRecogMeasureItemContext.class);
}
public MatchRecogMeasureItemContext matchRecogMeasureItem(int i) {
return getRuleContext(MatchRecogMeasureItemContext.class,i);
}
public List<TerminalNode> 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, 258, RULE_matchRecogMeasures);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1870);
match(MEASURES);
setState(1871);
matchRecogMeasureItem();
setState(1876);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1872);
match(COMMA);
setState(1873);
matchRecogMeasureItem();
}
}
setState(1878);
_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, 260, RULE_matchRecogMeasureItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1879);
expression();
setState(1884);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1880);
match(AS);
setState(1882);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1881);
((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, 262, RULE_matchRecogMatchesSelection);
try {
enterOuterAlt(_localctx, 1);
{
setState(1886);
match(ALL);
setState(1887);
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, 264, RULE_matchRecogPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(1889);
match(PATTERN);
setState(1890);
match(LPAREN);
setState(1891);
matchRecogPatternAlteration();
setState(1892);
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<KeywordAllowedIdentContext> 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, 266, RULE_matchRecogMatchesAfterSkip);
try {
enterOuterAlt(_localctx, 1);
{
setState(1894);
match(AFTER);
setState(1895);
((MatchRecogMatchesAfterSkipContext)_localctx).i1 = keywordAllowedIdent();
setState(1896);
((MatchRecogMatchesAfterSkipContext)_localctx).i2 = keywordAllowedIdent();
setState(1897);
((MatchRecogMatchesAfterSkipContext)_localctx).i3 = keywordAllowedIdent();
setState(1898);
((MatchRecogMatchesAfterSkipContext)_localctx).i4 = keywordAllowedIdent();
setState(1899);
((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, 268, RULE_matchRecogMatchesInterval);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1901);
((MatchRecogMatchesIntervalContext)_localctx).i = match(IDENT);
setState(1902);
timePeriod();
setState(1905);
_la = _input.LA(1);
if (_la==OR_EXPR) {
{
setState(1903);
match(OR_EXPR);
setState(1904);
((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<MatchRecogPatternConcatContext> matchRecogPatternConcat() {
return getRuleContexts(MatchRecogPatternConcatContext.class);
}
public MatchRecogPatternConcatContext matchRecogPatternConcat(int i) {
return getRuleContext(MatchRecogPatternConcatContext.class,i);
}
public List<TerminalNode> 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, 270, RULE_matchRecogPatternAlteration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1907);
matchRecogPatternConcat();
setState(1912);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BOR) {
{
{
setState(1908);
((MatchRecogPatternAlterationContext)_localctx).o = match(BOR);
setState(1909);
matchRecogPatternConcat();
}
}
setState(1914);
_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<MatchRecogPatternUnaryContext> 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, 272, RULE_matchRecogPatternConcat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1916);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1915);
matchRecogPatternUnary();
}
}
setState(1918);
_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, 274, RULE_matchRecogPatternUnary);
try {
setState(1923);
switch (_input.LA(1)) {
case MATCH_RECOGNIZE_PERMUTE:
enterOuterAlt(_localctx, 1);
{
setState(1920);
matchRecogPatternPermute();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(1921);
matchRecogPatternNested();
}
break;
case IDENT:
enterOuterAlt(_localctx, 3);
{
setState(1922);
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, 276, RULE_matchRecogPatternNested);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1925);
match(LPAREN);
setState(1926);
matchRecogPatternAlteration();
setState(1927);
match(RPAREN);
setState(1931);
switch (_input.LA(1)) {
case STAR:
{
setState(1928);
((MatchRecogPatternNestedContext)_localctx).s = match(STAR);
}
break;
case PLUS:
{
setState(1929);
((MatchRecogPatternNestedContext)_localctx).s = match(PLUS);
}
break;
case QUESTION:
{
setState(1930);
((MatchRecogPatternNestedContext)_localctx).s = match(QUESTION);
}
break;
case MATCH_RECOGNIZE_PERMUTE:
case LPAREN:
case RPAREN:
case LCURLY:
case COMMA:
case BOR:
case IDENT:
break;
default:
throw new NoViableAltException(this);
}
setState(1934);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(1933);
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<MatchRecogPatternAlterationContext> 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<TerminalNode> 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, 278, RULE_matchRecogPatternPermute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1936);
match(MATCH_RECOGNIZE_PERMUTE);
setState(1937);
match(LPAREN);
setState(1938);
matchRecogPatternAlteration();
setState(1943);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1939);
match(COMMA);
setState(1940);
matchRecogPatternAlteration();
}
}
setState(1945);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1946);
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<TerminalNode> 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, 280, RULE_matchRecogPatternAtom);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1948);
((MatchRecogPatternAtomContext)_localctx).i = match(IDENT);
setState(1957);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (STAR - 143)))) != 0)) {
{
setState(1952);
switch (_input.LA(1)) {
case STAR:
{
setState(1949);
((MatchRecogPatternAtomContext)_localctx).s = match(STAR);
}
break;
case PLUS:
{
setState(1950);
((MatchRecogPatternAtomContext)_localctx).s = match(PLUS);
}
break;
case QUESTION:
{
setState(1951);
((MatchRecogPatternAtomContext)_localctx).s = match(QUESTION);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1955);
_la = _input.LA(1);
if (_la==QUESTION) {
{
setState(1954);
((MatchRecogPatternAtomContext)_localctx).reluctant = match(QUESTION);
}
}
}
}
setState(1960);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(1959);
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<ExpressionContext> 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, 282, RULE_matchRecogPatternRepeat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1962);
match(LCURLY);
setState(1964);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) {
case 1:
{
setState(1963);
((MatchRecogPatternRepeatContext)_localctx).e1 = expression();
}
break;
}
setState(1967);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1966);
((MatchRecogPatternRepeatContext)_localctx).comma = match(COMMA);
}
}
setState(1970);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(1969);
((MatchRecogPatternRepeatContext)_localctx).e2 = expression();
}
}
setState(1972);
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<MatchRecogDefineItemContext> matchRecogDefineItem() {
return getRuleContexts(MatchRecogDefineItemContext.class);
}
public MatchRecogDefineItemContext matchRecogDefineItem(int i) {
return getRuleContext(MatchRecogDefineItemContext.class,i);
}
public List<TerminalNode> 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, 284, RULE_matchRecogDefine);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1974);
match(DEFINE);
setState(1975);
matchRecogDefineItem();
setState(1980);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1976);
match(COMMA);
setState(1977);
matchRecogDefineItem();
}
}
setState(1982);
_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, 286, RULE_matchRecogDefineItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1983);
((MatchRecogDefineItemContext)_localctx).i = match(IDENT);
setState(1984);
match(AS);
setState(1985);
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, 288, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1987);
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<WhenClauseContext> 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, 290, RULE_caseExpression);
int _la;
try {
setState(2017);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,260,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
paraphrases.push("case expression");
setState(1990);
match(CASE);
setState(1992);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1991);
whenClause();
}
}
setState(1994);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(1997);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(1996);
elseClause();
}
}
setState(1999);
match(END);
paraphrases.pop();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
paraphrases.push("case expression");
setState(2003);
match(CASE);
setState(2004);
expression();
setState(2006);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2005);
whenClause();
}
}
setState(2008);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(2011);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(2010);
elseClause();
}
}
setState(2013);
match(END);
paraphrases.pop();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2016);
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<EvalAndExpressionContext> evalAndExpression() {
return getRuleContexts(EvalAndExpressionContext.class);
}
public EvalAndExpressionContext evalAndExpression(int i) {
return getRuleContext(EvalAndExpressionContext.class,i);
}
public List<TerminalNode> 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, 292, RULE_evalOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2019);
evalAndExpression();
setState(2024);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_EXPR) {
{
{
setState(2020);
((EvalOrExpressionContext)_localctx).op = match(OR_EXPR);
setState(2021);
evalAndExpression();
}
}
setState(2026);
_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<BitWiseExpressionContext> bitWiseExpression() {
return getRuleContexts(BitWiseExpressionContext.class);
}
public BitWiseExpressionContext bitWiseExpression(int i) {
return getRuleContext(BitWiseExpressionContext.class,i);
}
public List<TerminalNode> 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, 294, RULE_evalAndExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2027);
bitWiseExpression();
setState(2032);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,262,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2028);
((EvalAndExpressionContext)_localctx).op = match(AND_EXPR);
setState(2029);
bitWiseExpression();
}
}
}
setState(2034);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,262,_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<NegatedExpressionContext> negatedExpression() {
return getRuleContexts(NegatedExpressionContext.class);
}
public NegatedExpressionContext negatedExpression(int i) {
return getRuleContext(NegatedExpressionContext.class,i);
}
public List<TerminalNode> BAND() { return getTokens(EsperEPL2GrammarParser.BAND); }
public TerminalNode BAND(int i) {
return getToken(EsperEPL2GrammarParser.BAND, i);
}
public List<TerminalNode> BOR() { return getTokens(EsperEPL2GrammarParser.BOR); }
public TerminalNode BOR(int i) {
return getToken(EsperEPL2GrammarParser.BOR, i);
}
public List<TerminalNode> 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, 296, RULE_bitWiseExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2035);
negatedExpression();
setState(2040);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 172)) & ~0x3f) == 0 && ((1L << (_la - 172)) & ((1L << (BXOR - 172)) | (1L << (BOR - 172)) | (1L << (BAND - 172)))) != 0)) {
{
{
setState(2036);
_la = _input.LA(1);
if ( !(((((_la - 172)) & ~0x3f) == 0 && ((1L << (_la - 172)) & ((1L << (BXOR - 172)) | (1L << (BOR - 172)) | (1L << (BAND - 172)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(2037);
negatedExpression();
}
}
setState(2042);
_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, 298, RULE_negatedExpression);
try {
setState(2046);
switch (_input.LA(1)) {
case WINDOW:
case ESCAPE:
case EVERY_EXPR:
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 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 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(2043);
evalEqualsExpression();
}
break;
case NOT_EXPR:
enterOuterAlt(_localctx, 2);
{
setState(2044);
match(NOT_EXPR);
setState(2045);
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<EvalRelationalExpressionContext> evalRelationalExpression() {
return getRuleContexts(EvalRelationalExpressionContext.class);
}
public EvalRelationalExpressionContext evalRelationalExpression(int i) {
return getRuleContext(EvalRelationalExpressionContext.class,i);
}
public List<TerminalNode> NOT_EXPR() { return getTokens(EsperEPL2GrammarParser.NOT_EXPR); }
public TerminalNode NOT_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.NOT_EXPR, i);
}
public List<TerminalNode> EQUALS() { return getTokens(EsperEPL2GrammarParser.EQUALS); }
public TerminalNode EQUALS(int i) {
return getToken(EsperEPL2GrammarParser.EQUALS, i);
}
public List<TerminalNode> IS() { return getTokens(EsperEPL2GrammarParser.IS); }
public TerminalNode IS(int i) {
return getToken(EsperEPL2GrammarParser.IS, i);
}
public List<TerminalNode> SQL_NE() { return getTokens(EsperEPL2GrammarParser.SQL_NE); }
public TerminalNode SQL_NE(int i) {
return getToken(EsperEPL2GrammarParser.SQL_NE, i);
}
public List<TerminalNode> NOT_EQUAL() { return getTokens(EsperEPL2GrammarParser.NOT_EQUAL); }
public TerminalNode NOT_EQUAL(int i) {
return getToken(EsperEPL2GrammarParser.NOT_EQUAL, i);
}
public List<SubSelectGroupExpressionContext> subSelectGroupExpression() {
return getRuleContexts(SubSelectGroupExpressionContext.class);
}
public SubSelectGroupExpressionContext subSelectGroupExpression(int i) {
return getRuleContext(SubSelectGroupExpressionContext.class,i);
}
public List<TerminalNode> ANY() { return getTokens(EsperEPL2GrammarParser.ANY); }
public TerminalNode ANY(int i) {
return getToken(EsperEPL2GrammarParser.ANY, i);
}
public List<TerminalNode> SOME() { return getTokens(EsperEPL2GrammarParser.SOME); }
public TerminalNode SOME(int i) {
return getToken(EsperEPL2GrammarParser.SOME, i);
}
public List<TerminalNode> ALL() { return getTokens(EsperEPL2GrammarParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(EsperEPL2GrammarParser.ALL, i);
}
public List<TerminalNode> LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public List<TerminalNode> RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public List<ExpressionListContext> 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, 300, RULE_evalEqualsExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2048);
evalRelationalExpression();
setState(2075);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IS || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & ((1L << (EQUALS - 141)) | (1L << (SQL_NE - 141)) | (1L << (NOT_EQUAL - 141)))) != 0)) {
{
{
setState(2055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,265,_ctx) ) {
case 1:
{
setState(2049);
((EvalEqualsExpressionContext)_localctx).eq = match(EQUALS);
}
break;
case 2:
{
setState(2050);
((EvalEqualsExpressionContext)_localctx).is = match(IS);
}
break;
case 3:
{
setState(2051);
((EvalEqualsExpressionContext)_localctx).isnot = match(IS);
setState(2052);
match(NOT_EXPR);
}
break;
case 4:
{
setState(2053);
((EvalEqualsExpressionContext)_localctx).sqlne = match(SQL_NE);
}
break;
case 5:
{
setState(2054);
((EvalEqualsExpressionContext)_localctx).ne = match(NOT_EQUAL);
}
break;
}
setState(2071);
switch (_input.LA(1)) {
case WINDOW:
case ESCAPE:
case EVERY_EXPR:
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 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 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(2057);
evalRelationalExpression();
}
break;
case ALL:
case ANY:
case SOME:
{
setState(2061);
switch (_input.LA(1)) {
case ANY:
{
setState(2058);
((EvalEqualsExpressionContext)_localctx).a = match(ANY);
}
break;
case SOME:
{
setState(2059);
((EvalEqualsExpressionContext)_localctx).a = match(SOME);
}
break;
case ALL:
{
setState(2060);
((EvalEqualsExpressionContext)_localctx).a = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2069);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,268,_ctx) ) {
case 1:
{
{
setState(2063);
match(LPAREN);
setState(2065);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2064);
expressionList();
}
}
setState(2067);
match(RPAREN);
}
}
break;
case 2:
{
setState(2068);
subSelectGroupExpression();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2077);
_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<ConcatenationExprContext> 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<ExpressionContext> 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<TerminalNode> 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<TerminalNode> 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<TerminalNode> LT() { return getTokens(EsperEPL2GrammarParser.LT); }
public TerminalNode LT(int i) {
return getToken(EsperEPL2GrammarParser.LT, i);
}
public List<TerminalNode> GT() { return getTokens(EsperEPL2GrammarParser.GT); }
public TerminalNode GT(int i) {
return getToken(EsperEPL2GrammarParser.GT, i);
}
public List<TerminalNode> LE() { return getTokens(EsperEPL2GrammarParser.LE); }
public TerminalNode LE(int i) {
return getToken(EsperEPL2GrammarParser.LE, i);
}
public List<TerminalNode> GE() { return getTokens(EsperEPL2GrammarParser.GE); }
public TerminalNode GE(int i) {
return getToken(EsperEPL2GrammarParser.GE, i);
}
public List<SubSelectGroupExpressionContext> 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<TerminalNode> ANY() { return getTokens(EsperEPL2GrammarParser.ANY); }
public TerminalNode ANY(int i) {
return getToken(EsperEPL2GrammarParser.ANY, i);
}
public List<TerminalNode> SOME() { return getTokens(EsperEPL2GrammarParser.SOME); }
public TerminalNode SOME(int i) {
return getToken(EsperEPL2GrammarParser.SOME, i);
}
public List<TerminalNode> ALL() { return getTokens(EsperEPL2GrammarParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(EsperEPL2GrammarParser.ALL, i);
}
public List<TerminalNode> COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List<ExpressionListContext> 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, 302, RULE_evalRelationalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2078);
concatenationExpr();
setState(2144);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,284,_ctx) ) {
case 1:
{
{
setState(2103);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 168)) & ~0x3f) == 0 && ((1L << (_la - 168)) & ((1L << (GE - 168)) | (1L << (GT - 168)) | (1L << (LE - 168)) | (1L << (LT - 168)))) != 0)) {
{
{
setState(2083);
switch (_input.LA(1)) {
case LT:
{
setState(2079);
((EvalRelationalExpressionContext)_localctx).r = match(LT);
}
break;
case GT:
{
setState(2080);
((EvalRelationalExpressionContext)_localctx).r = match(GT);
}
break;
case LE:
{
setState(2081);
((EvalRelationalExpressionContext)_localctx).r = match(LE);
}
break;
case GE:
{
setState(2082);
((EvalRelationalExpressionContext)_localctx).r = match(GE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2099);
switch (_input.LA(1)) {
case WINDOW:
case ESCAPE:
case EVERY_EXPR:
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 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 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(2085);
concatenationExpr();
}
break;
case ALL:
case ANY:
case SOME:
{
setState(2089);
switch (_input.LA(1)) {
case ANY:
{
setState(2086);
((EvalRelationalExpressionContext)_localctx).g = match(ANY);
}
break;
case SOME:
{
setState(2087);
((EvalRelationalExpressionContext)_localctx).g = match(SOME);
}
break;
case ALL:
{
setState(2088);
((EvalRelationalExpressionContext)_localctx).g = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2097);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) {
case 1:
{
{
setState(2091);
match(LPAREN);
setState(2093);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2092);
expressionList();
}
}
setState(2095);
match(RPAREN);
}
}
break;
case 2:
{
setState(2096);
subSelectGroupExpression();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2105);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case 2:
{
setState(2107);
_la = _input.LA(1);
if (_la==NOT_EXPR) {
{
setState(2106);
((EvalRelationalExpressionContext)_localctx).n = match(NOT_EXPR);
}
}
setState(2142);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) {
case 1:
{
{
setState(2109);
((EvalRelationalExpressionContext)_localctx).in = match(IN_SET);
setState(2112);
switch (_input.LA(1)) {
case LPAREN:
{
setState(2110);
((EvalRelationalExpressionContext)_localctx).l = match(LPAREN);
}
break;
case LBRACK:
{
setState(2111);
((EvalRelationalExpressionContext)_localctx).l = match(LBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2114);
expression();
setState(2124);
switch (_input.LA(1)) {
case COLON:
{
{
setState(2115);
((EvalRelationalExpressionContext)_localctx).col = match(COLON);
{
setState(2116);
expression();
}
}
}
break;
case RPAREN:
case RBRACK:
case COMMA:
{
{
setState(2121);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2117);
match(COMMA);
setState(2118);
expression();
}
}
setState(2123);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2128);
switch (_input.LA(1)) {
case RPAREN:
{
setState(2126);
((EvalRelationalExpressionContext)_localctx).r = match(RPAREN);
}
break;
case RBRACK:
{
setState(2127);
((EvalRelationalExpressionContext)_localctx).r = match(RBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
case 2:
{
setState(2130);
((EvalRelationalExpressionContext)_localctx).inset = match(IN_SET);
setState(2131);
inSubSelectQuery();
}
break;
case 3:
{
setState(2132);
((EvalRelationalExpressionContext)_localctx).between = match(BETWEEN);
setState(2133);
betweenList();
}
break;
case 4:
{
setState(2134);
((EvalRelationalExpressionContext)_localctx).like = match(LIKE);
setState(2135);
concatenationExpr();
setState(2138);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,282,_ctx) ) {
case 1:
{
setState(2136);
match(ESCAPE);
setState(2137);
stringconstant();
}
break;
}
}
break;
case 5:
{
setState(2140);
((EvalRelationalExpressionContext)_localctx).regex = match(REGEXP);
setState(2141);
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, 304, RULE_inSubSelectQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(2146);
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<AdditiveExpressionContext> additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public List<TerminalNode> 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, 306, RULE_concatenationExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2148);
additiveExpression();
setState(2158);
_la = _input.LA(1);
if (_la==LOR) {
{
setState(2149);
((ConcatenationExprContext)_localctx).c = match(LOR);
setState(2150);
additiveExpression();
setState(2155);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOR) {
{
{
setState(2151);
match(LOR);
setState(2152);
additiveExpression();
}
}
setState(2157);
_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<MultiplyExpressionContext> multiplyExpression() {
return getRuleContexts(MultiplyExpressionContext.class);
}
public MultiplyExpressionContext multiplyExpression(int i) {
return getRuleContext(MultiplyExpressionContext.class,i);
}
public List<TerminalNode> PLUS() { return getTokens(EsperEPL2GrammarParser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(EsperEPL2GrammarParser.PLUS, i);
}
public List<TerminalNode> 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, 308, RULE_additiveExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2160);
multiplyExpression();
setState(2165);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,287,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2161);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(2162);
multiplyExpression();
}
}
}
setState(2167);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,287,_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<UnaryExpressionContext> unaryExpression() {
return getRuleContexts(UnaryExpressionContext.class);
}
public UnaryExpressionContext unaryExpression(int i) {
return getRuleContext(UnaryExpressionContext.class,i);
}
public List<TerminalNode> STAR() { return getTokens(EsperEPL2GrammarParser.STAR); }
public TerminalNode STAR(int i) {
return getToken(EsperEPL2GrammarParser.STAR, i);
}
public List<TerminalNode> DIV() { return getTokens(EsperEPL2GrammarParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(EsperEPL2GrammarParser.DIV, i);
}
public List<TerminalNode> 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, 310, RULE_multiplyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2168);
unaryExpression();
setState(2173);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 156)) & ~0x3f) == 0 && ((1L << (_la - 156)) & ((1L << (DIV - 156)) | (1L << (STAR - 156)) | (1L << (MOD - 156)))) != 0)) {
{
{
setState(2169);
_la = _input.LA(1);
if ( !(((((_la - 156)) & ~0x3f) == 0 && ((1L << (_la - 156)) & ((1L << (DIV - 156)) | (1L << (STAR - 156)) | (1L << (MOD - 156)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(2170);
unaryExpression();
}
}
setState(2175);
_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 Token b;
public TerminalNode MINUS() { return getToken(EsperEPL2GrammarParser.MINUS, 0); }
public EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public SubstitutionCanChainContext substitutionCanChain() {
return getRuleContext(SubstitutionCanChainContext.class,0);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.class,0);
}
public BuiltinFuncContext builtinFunc() {
return getRuleContext(BuiltinFuncContext.class,0);
}
public EventPropertyOrLibFunctionContext eventPropertyOrLibFunction() {
return getRuleContext(EventPropertyOrLibFunctionContext.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<NewAssignContext> 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<TerminalNode> COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,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 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, 312, RULE_unaryExpression);
int _la;
try {
setState(2235);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,296,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2176);
match(MINUS);
setState(2177);
eventProperty();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2178);
constant();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2179);
substitutionCanChain();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2180);
((UnaryExpressionContext)_localctx).inner = match(LPAREN);
setState(2181);
expression();
setState(2182);
match(RPAREN);
setState(2184);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2183);
chainedFunction();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2186);
builtinFunc();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2187);
eventPropertyOrLibFunction();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2188);
arrayExpression();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2189);
rowSubSelectExpression();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2190);
existsSubSelectExpression();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2191);
match(NEWKW);
setState(2192);
match(LCURLY);
setState(2193);
newAssign();
setState(2198);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2194);
match(COMMA);
setState(2195);
newAssign();
}
}
setState(2200);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2201);
match(RCURLY);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2203);
match(NEWKW);
setState(2204);
classIdentifier();
setState(2205);
match(LPAREN);
setState(2214);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2206);
expression();
setState(2211);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2207);
match(COMMA);
setState(2208);
expression();
}
}
setState(2213);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2216);
match(RPAREN);
setState(2218);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2217);
chainedFunction();
}
}
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2220);
((UnaryExpressionContext)_localctx).b = match(IDENT);
setState(2221);
match(LBRACK);
setState(2222);
expression();
setState(2227);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2223);
match(COMMA);
setState(2224);
expression();
}
}
setState(2229);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2230);
match(RBRACK);
setState(2232);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2231);
chainedFunction();
}
}
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2234);
jsonobject();
}
break;
}
}
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 ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.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, 314, RULE_substitutionCanChain);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2237);
substitution();
setState(2239);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2238);
chainedFunction();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChainedFunctionContext extends ParserRuleContext {
public Token d;
public List<LibFunctionNoClassContext> libFunctionNoClass() {
return getRuleContexts(LibFunctionNoClassContext.class);
}
public LibFunctionNoClassContext libFunctionNoClass(int i) {
return getRuleContext(LibFunctionNoClassContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public ChainedFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_chainedFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterChainedFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitChainedFunction(this);
}
}
public final ChainedFunctionContext chainedFunction() throws RecognitionException {
ChainedFunctionContext _localctx = new ChainedFunctionContext(_ctx, getState());
enterRule(_localctx, 316, RULE_chainedFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2241);
((ChainedFunctionContext)_localctx).d = match(DOT);
setState(2242);
libFunctionNoClass();
setState(2247);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2243);
((ChainedFunctionContext)_localctx).d = match(DOT);
setState(2244);
libFunctionNoClass();
}
}
setState(2249);
_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 NewAssignContext extends ParserRuleContext {
public EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.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, 318, RULE_newAssign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2250);
eventProperty();
setState(2253);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(2251);
match(EQUALS);
setState(2252);
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 ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.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, 320, RULE_rowSubSelectExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2255);
subQueryExpr();
setState(2257);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2256);
chainedFunction();
}
}
}
}
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, 322, RULE_subSelectGroupExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2259);
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, 324, RULE_existsSubSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2261);
match(EXISTS);
setState(2262);
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, 326, RULE_subQueryExpr);
paraphrases.push("subquery");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2264);
match(LPAREN);
setState(2265);
match(SELECT);
setState(2267);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(2266);
match(DISTINCT);
}
}
setState(2269);
selectionList();
setState(2270);
match(FROM);
setState(2271);
subSelectFilterExpr();
setState(2274);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2272);
match(WHERE);
setState(2273);
whereClause();
}
}
setState(2279);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(2276);
match(GROUP);
setState(2277);
match(BY);
setState(2278);
groupByListExpr();
}
}
setState(2283);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(2281);
match(HAVING);
setState(2282);
havingClause();
}
}
setState(2285);
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 i;
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 TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 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, 328, RULE_subSelectFilterExpr);
paraphrases.push("subquery filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2287);
eventFilterExpression();
setState(2289);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(2288);
viewExpressions();
}
}
setState(2294);
switch (_input.LA(1)) {
case AS:
{
setState(2291);
match(AS);
setState(2292);
((SubSelectFilterExprContext)_localctx).i = match(IDENT);
}
break;
case IDENT:
{
setState(2293);
((SubSelectFilterExprContext)_localctx).i = match(IDENT);
}
break;
case WHERE:
case GROUP:
case HAVING:
case RETAINUNION:
case RETAININTERSECTION:
case RPAREN:
break;
default:
throw new NoViableAltException(this);
}
setState(2298);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(2296);
((SubSelectFilterExprContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(2297);
((SubSelectFilterExprContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case WHERE:
case GROUP:
case HAVING:
case RPAREN:
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 ArrayExpressionContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.class,0);
}
public List<TerminalNode> 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, 330, RULE_arrayExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2300);
match(LCURLY);
setState(2309);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2301);
expression();
setState(2306);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2302);
match(COMMA);
setState(2303);
expression();
}
}
setState(2308);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2311);
match(RCURLY);
setState(2313);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2312);
chainedFunction();
}
}
}
}
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 ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List<TerminalNode> 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 ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.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 EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.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 EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.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<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.class,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 TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.class,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<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> 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<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.class,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 ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.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<TerminalNode> COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List<ClassIdentifierContext> 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, 332, RULE_builtinFunc);
int _la;
try {
setState(2478);
switch (_input.LA(1)) {
case SUM:
_localctx = new Builtin_sumContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2315);
match(SUM);
setState(2316);
match(LPAREN);
setState(2318);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2317);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(2320);
expressionListWithNamed();
setState(2321);
match(RPAREN);
}
break;
case AVG:
_localctx = new Builtin_avgContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2323);
match(AVG);
setState(2324);
match(LPAREN);
setState(2326);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2325);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(2328);
expressionListWithNamed();
setState(2329);
match(RPAREN);
}
break;
case COUNT:
_localctx = new Builtin_cntContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2331);
match(COUNT);
setState(2332);
match(LPAREN);
setState(2335);
switch (_input.LA(1)) {
case ALL:
{
setState(2333);
((Builtin_cntContext)_localctx).a = match(ALL);
}
break;
case DISTINCT:
{
setState(2334);
((Builtin_cntContext)_localctx).d = match(DISTINCT);
}
break;
case WINDOW:
case ESCAPE:
case NOT_EXPR:
case EVERY_EXPR:
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 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 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:
throw new NoViableAltException(this);
}
setState(2337);
expressionListWithNamed();
setState(2338);
match(RPAREN);
}
break;
case MEDIAN:
_localctx = new Builtin_medianContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2340);
match(MEDIAN);
setState(2341);
match(LPAREN);
setState(2343);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2342);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(2345);
expressionListWithNamed();
setState(2346);
match(RPAREN);
}
break;
case STDDEV:
_localctx = new Builtin_stddevContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2348);
match(STDDEV);
setState(2349);
match(LPAREN);
setState(2351);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2350);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(2353);
expressionListWithNamed();
setState(2354);
match(RPAREN);
}
break;
case AVEDEV:
_localctx = new Builtin_avedevContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2356);
match(AVEDEV);
setState(2357);
match(LPAREN);
setState(2359);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2358);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(2361);
expressionListWithNamed();
setState(2362);
match(RPAREN);
}
break;
case WINDOW:
case FIRST:
case LAST:
_localctx = new Builtin_firstlastwindowContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2364);
firstLastWindowAggregation();
}
break;
case COALESCE:
_localctx = new Builtin_coalesceContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(2365);
match(COALESCE);
setState(2366);
match(LPAREN);
setState(2367);
expression();
setState(2368);
match(COMMA);
setState(2369);
expression();
setState(2374);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2370);
match(COMMA);
setState(2371);
expression();
}
}
setState(2376);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2377);
match(RPAREN);
}
break;
case PREVIOUS:
_localctx = new Builtin_prevContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(2379);
match(PREVIOUS);
setState(2380);
match(LPAREN);
setState(2381);
expression();
setState(2384);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2382);
match(COMMA);
setState(2383);
expression();
}
}
setState(2386);
match(RPAREN);
setState(2388);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2387);
chainedFunction();
}
}
}
break;
case PREVIOUSTAIL:
_localctx = new Builtin_prevtailContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(2390);
match(PREVIOUSTAIL);
setState(2391);
match(LPAREN);
setState(2392);
expression();
setState(2395);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2393);
match(COMMA);
setState(2394);
expression();
}
}
setState(2397);
match(RPAREN);
setState(2399);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2398);
chainedFunction();
}
}
}
break;
case PREVIOUSCOUNT:
_localctx = new Builtin_prevcountContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(2401);
match(PREVIOUSCOUNT);
setState(2402);
match(LPAREN);
setState(2403);
expression();
setState(2404);
match(RPAREN);
}
break;
case PREVIOUSWINDOW:
_localctx = new Builtin_prevwindowContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(2406);
match(PREVIOUSWINDOW);
setState(2407);
match(LPAREN);
setState(2408);
expression();
setState(2409);
match(RPAREN);
setState(2411);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2410);
chainedFunction();
}
}
}
break;
case PRIOR:
_localctx = new Builtin_priorContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(2413);
match(PRIOR);
setState(2414);
match(LPAREN);
setState(2415);
expression();
setState(2416);
match(COMMA);
setState(2417);
eventProperty();
setState(2418);
match(RPAREN);
}
break;
case GROUPING:
_localctx = new Builtin_groupingContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(2420);
match(GROUPING);
setState(2421);
match(LPAREN);
setState(2422);
expression();
setState(2423);
match(RPAREN);
}
break;
case GROUPING_ID:
_localctx = new Builtin_groupingidContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(2425);
match(GROUPING_ID);
setState(2426);
match(LPAREN);
setState(2427);
expressionList();
setState(2428);
match(RPAREN);
}
break;
case INSTANCEOF:
_localctx = new Builtin_instanceofContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(2430);
match(INSTANCEOF);
setState(2431);
match(LPAREN);
setState(2432);
expression();
setState(2433);
match(COMMA);
setState(2434);
classIdentifier();
setState(2439);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2435);
match(COMMA);
setState(2436);
classIdentifier();
}
}
setState(2441);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2442);
match(RPAREN);
}
break;
case TYPEOF:
_localctx = new Builtin_typeofContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(2444);
match(TYPEOF);
setState(2445);
match(LPAREN);
setState(2446);
expression();
setState(2447);
match(RPAREN);
}
break;
case CAST:
_localctx = new Builtin_castContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(2449);
match(CAST);
setState(2450);
match(LPAREN);
setState(2451);
expression();
setState(2452);
_la = _input.LA(1);
if ( !(_la==AS || _la==COMMA) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(2453);
classIdentifier();
setState(2456);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2454);
match(COMMA);
setState(2455);
expressionNamedParameter();
}
}
setState(2458);
match(RPAREN);
setState(2460);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2459);
chainedFunction();
}
}
}
break;
case EXISTS:
_localctx = new Builtin_existsContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(2462);
match(EXISTS);
setState(2463);
match(LPAREN);
setState(2464);
eventProperty();
setState(2465);
match(RPAREN);
}
break;
case CURRENT_TIMESTAMP:
_localctx = new Builtin_currtsContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(2467);
match(CURRENT_TIMESTAMP);
setState(2470);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,326,_ctx) ) {
case 1:
{
setState(2468);
match(LPAREN);
setState(2469);
match(RPAREN);
}
break;
}
setState(2473);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2472);
chainedFunction();
}
}
}
break;
case ISTREAM:
_localctx = new Builtin_istreamContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(2475);
match(ISTREAM);
setState(2476);
match(LPAREN);
setState(2477);
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 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 ChainedFunctionContext chainedFunction() {
return getRuleContext(ChainedFunctionContext.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, 334, RULE_firstLastWindowAggregation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2483);
switch (_input.LA(1)) {
case FIRST:
{
setState(2480);
((FirstLastWindowAggregationContext)_localctx).q = match(FIRST);
}
break;
case LAST:
{
setState(2481);
((FirstLastWindowAggregationContext)_localctx).q = match(LAST);
}
break;
case WINDOW:
{
setState(2482);
((FirstLastWindowAggregationContext)_localctx).q = match(WINDOW);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2485);
match(LPAREN);
setState(2487);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2486);
expressionListWithNamed();
}
}
setState(2489);
match(RPAREN);
setState(2491);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2490);
chainedFunction();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EventPropertyOrLibFunctionContext extends ParserRuleContext {
public EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.class,0);
}
public LibFunctionContext libFunction() {
return getRuleContext(LibFunctionContext.class,0);
}
public EventPropertyOrLibFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eventPropertyOrLibFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEventPropertyOrLibFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEventPropertyOrLibFunction(this);
}
}
public final EventPropertyOrLibFunctionContext eventPropertyOrLibFunction() throws RecognitionException {
EventPropertyOrLibFunctionContext _localctx = new EventPropertyOrLibFunctionContext(_ctx, getState());
enterRule(_localctx, 336, RULE_eventPropertyOrLibFunction);
try {
setState(2495);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,332,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2493);
eventProperty();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2494);
libFunction();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LibFunctionContext extends ParserRuleContext {
public LibFunctionWithClassContext libFunctionWithClass() {
return getRuleContext(LibFunctionWithClassContext.class,0);
}
public List<TerminalNode> DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public List<LibFunctionNoClassContext> libFunctionNoClass() {
return getRuleContexts(LibFunctionNoClassContext.class);
}
public LibFunctionNoClassContext libFunctionNoClass(int i) {
return getRuleContext(LibFunctionNoClassContext.class,i);
}
public LibFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLibFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLibFunction(this);
}
}
public final LibFunctionContext libFunction() throws RecognitionException {
LibFunctionContext _localctx = new LibFunctionContext(_ctx, getState());
enterRule(_localctx, 338, RULE_libFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2497);
libFunctionWithClass();
setState(2502);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2498);
match(DOT);
setState(2499);
libFunctionNoClass();
}
}
setState(2504);
_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 LibFunctionWithClassContext extends ParserRuleContext {
public Token l;
public FuncIdentTopContext funcIdentTop() {
return getRuleContext(FuncIdentTopContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode DOT() { return getToken(EsperEPL2GrammarParser.DOT, 0); }
public FuncIdentInnerContext funcIdentInner() {
return getRuleContext(FuncIdentInnerContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public LibFunctionArgsContext libFunctionArgs() {
return getRuleContext(LibFunctionArgsContext.class,0);
}
public LibFunctionWithClassContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libFunctionWithClass; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLibFunctionWithClass(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLibFunctionWithClass(this);
}
}
public final LibFunctionWithClassContext libFunctionWithClass() throws RecognitionException {
LibFunctionWithClassContext _localctx = new LibFunctionWithClassContext(_ctx, getState());
enterRule(_localctx, 340, RULE_libFunctionWithClass);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2510);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,334,_ctx) ) {
case 1:
{
{
setState(2505);
classIdentifier();
setState(2506);
match(DOT);
setState(2507);
funcIdentInner();
}
}
break;
case 2:
{
setState(2509);
funcIdentTop();
}
break;
}
setState(2517);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,336,_ctx) ) {
case 1:
{
setState(2512);
((LibFunctionWithClassContext)_localctx).l = match(LPAREN);
setState(2514);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (DISTINCT - 2)) | (1L << (ALL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2513);
libFunctionArgs();
}
}
setState(2516);
match(RPAREN);
}
break;
}
}
}
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, 342, RULE_libFunctionNoClass);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2519);
funcIdentChained();
setState(2525);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,338,_ctx) ) {
case 1:
{
setState(2520);
((LibFunctionNoClassContext)_localctx).l = match(LPAREN);
setState(2522);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (DISTINCT - 2)) | (1L << (ALL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2521);
libFunctionArgs();
}
}
setState(2524);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncIdentTopContext extends ParserRuleContext {
public EscapableIdentContext escapableIdent() {
return getRuleContext(EscapableIdentContext.class,0);
}
public TerminalNode MAX() { return getToken(EsperEPL2GrammarParser.MAX, 0); }
public TerminalNode MIN() { return getToken(EsperEPL2GrammarParser.MIN, 0); }
public FuncIdentTopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcIdentTop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFuncIdentTop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFuncIdentTop(this);
}
}
public final FuncIdentTopContext funcIdentTop() throws RecognitionException {
FuncIdentTopContext _localctx = new FuncIdentTopContext(_ctx, getState());
enterRule(_localctx, 344, RULE_funcIdentTop);
try {
setState(2530);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2527);
escapableIdent();
}
break;
case MAX:
enterOuterAlt(_localctx, 2);
{
setState(2528);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 3);
{
setState(2529);
match(MIN);
}
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 FuncIdentInnerContext 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 FuncIdentInnerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcIdentInner; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFuncIdentInner(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFuncIdentInner(this);
}
}
public final FuncIdentInnerContext funcIdentInner() throws RecognitionException {
FuncIdentInnerContext _localctx = new FuncIdentInnerContext(_ctx, getState());
enterRule(_localctx, 346, RULE_funcIdentInner);
try {
setState(2536);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2532);
escapableIdent();
}
break;
case LAST:
enterOuterAlt(_localctx, 2);
{
setState(2533);
match(LAST);
}
break;
case FIRST:
enterOuterAlt(_localctx, 3);
{
setState(2534);
match(FIRST);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 4);
{
setState(2535);
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 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, 348, RULE_funcIdentChained);
try {
setState(2548);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2538);
escapableIdent();
}
break;
case LAST:
enterOuterAlt(_localctx, 2);
{
setState(2539);
match(LAST);
}
break;
case FIRST:
enterOuterAlt(_localctx, 3);
{
setState(2540);
match(FIRST);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 4);
{
setState(2541);
match(WINDOW);
}
break;
case MAX:
enterOuterAlt(_localctx, 5);
{
setState(2542);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 6);
{
setState(2543);
match(MIN);
}
break;
case WHERE:
enterOuterAlt(_localctx, 7);
{
setState(2544);
match(WHERE);
}
break;
case SET:
enterOuterAlt(_localctx, 8);
{
setState(2545);
match(SET);
}
break;
case AFTER:
enterOuterAlt(_localctx, 9);
{
setState(2546);
match(AFTER);
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 10);
{
setState(2547);
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<LibFunctionArgItemContext> libFunctionArgItem() {
return getRuleContexts(LibFunctionArgItemContext.class);
}
public LibFunctionArgItemContext libFunctionArgItem(int i) {
return getRuleContext(LibFunctionArgItemContext.class,i);
}
public List<TerminalNode> 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, 350, RULE_libFunctionArgs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2551);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2550);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(2553);
libFunctionArgItem();
setState(2558);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2554);
match(COMMA);
setState(2555);
libFunctionArgItem();
}
}
setState(2560);
_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, 352, RULE_libFunctionArgItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2562);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,344,_ctx) ) {
case 1:
{
setState(2561);
expressionLambdaDecl();
}
break;
}
setState(2564);
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<ConcatenationExprContext> 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, 354, RULE_betweenList);
try {
enterOuterAlt(_localctx, 1);
{
setState(2566);
concatenationExpr();
setState(2567);
match(AND_EXPR);
setState(2568);
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, 356, RULE_patternExpression);
paraphrases.push("pattern expression");
try {
enterOuterAlt(_localctx, 1);
{
setState(2570);
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<FollowedByRepeatContext> 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, 358, RULE_followedByExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2572);
orExpression();
setState(2576);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOLLOWMAX_BEGIN || _la==FOLLOWED_BY) {
{
{
setState(2573);
followedByRepeat();
}
}
setState(2578);
_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 FOLLOWMAX_END() { return getToken(EsperEPL2GrammarParser.FOLLOWMAX_END, 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, 360, RULE_followedByRepeat);
try {
enterOuterAlt(_localctx, 1);
{
setState(2584);
switch (_input.LA(1)) {
case FOLLOWED_BY:
{
setState(2579);
((FollowedByRepeatContext)_localctx).f = match(FOLLOWED_BY);
}
break;
case FOLLOWMAX_BEGIN:
{
{
setState(2580);
((FollowedByRepeatContext)_localctx).g = match(FOLLOWMAX_BEGIN);
setState(2581);
expression();
setState(2582);
match(FOLLOWMAX_END);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2586);
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<AndExpressionContext> andExpression() {
return getRuleContexts(AndExpressionContext.class);
}
public AndExpressionContext andExpression(int i) {
return getRuleContext(AndExpressionContext.class,i);
}
public List<TerminalNode> 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, 362, RULE_orExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2588);
andExpression();
setState(2593);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_EXPR) {
{
{
setState(2589);
((OrExpressionContext)_localctx).o = match(OR_EXPR);
setState(2590);
andExpression();
}
}
setState(2595);
_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<MatchUntilExpressionContext> matchUntilExpression() {
return getRuleContexts(MatchUntilExpressionContext.class);
}
public MatchUntilExpressionContext matchUntilExpression(int i) {
return getRuleContext(MatchUntilExpressionContext.class,i);
}
public List<TerminalNode> 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, 364, RULE_andExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2596);
matchUntilExpression();
setState(2601);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR) {
{
{
setState(2597);
((AndExpressionContext)_localctx).a = match(AND_EXPR);
setState(2598);
matchUntilExpression();
}
}
setState(2603);
_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<QualifyExpressionContext> 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, 366, RULE_matchUntilExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2605);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2604);
((MatchUntilExpressionContext)_localctx).r = matchUntilRange();
}
}
setState(2607);
qualifyExpression();
setState(2610);
_la = _input.LA(1);
if (_la==UNTIL) {
{
setState(2608);
match(UNTIL);
setState(2609);
((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, 368, RULE_qualifyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2621);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << EVERY_DISTINCT_EXPR))) != 0)) {
{
setState(2616);
switch (_input.LA(1)) {
case EVERY_EXPR:
{
setState(2612);
((QualifyExpressionContext)_localctx).e = match(EVERY_EXPR);
}
break;
case NOT_EXPR:
{
setState(2613);
((QualifyExpressionContext)_localctx).n = match(NOT_EXPR);
}
break;
case EVERY_DISTINCT_EXPR:
{
setState(2614);
((QualifyExpressionContext)_localctx).d = match(EVERY_DISTINCT_EXPR);
setState(2615);
distinctExpressionList();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2619);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2618);
matchUntilRange();
}
}
}
}
setState(2623);
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, 370, RULE_guardPostFix);
try {
enterOuterAlt(_localctx, 1);
{
setState(2630);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(2625);
atomicExpression();
}
break;
case LPAREN:
{
setState(2626);
((GuardPostFixContext)_localctx).l = match(LPAREN);
setState(2627);
patternExpression();
setState(2628);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2636);
switch (_input.LA(1)) {
case WHERE:
{
{
setState(2632);
((GuardPostFixContext)_localctx).wh = match(WHERE);
setState(2633);
guardWhereExpression();
}
}
break;
case WHILE:
{
{
setState(2634);
((GuardPostFixContext)_localctx).wi = match(WHILE);
setState(2635);
guardWhileExpression();
}
}
break;
case EOF:
case OR_EXPR:
case AND_EXPR:
case UNTIL:
case FOLLOWMAX_BEGIN:
case FOLLOWED_BY:
case RPAREN:
case 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 DistinctExpressionListContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List<DistinctExpressionAtomContext> 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<TerminalNode> 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, 372, RULE_distinctExpressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2638);
match(LPAREN);
setState(2639);
distinctExpressionAtom();
setState(2644);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2640);
match(COMMA);
setState(2641);
distinctExpressionAtom();
}
}
setState(2646);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2647);
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, 374, RULE_distinctExpressionAtom);
try {
enterOuterAlt(_localctx, 1);
{
setState(2649);
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, 376, RULE_atomicExpression);
try {
setState(2653);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,357,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2651);
observerExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2652);
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<TerminalNode> 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, 378, RULE_observerExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2655);
((ObserverExpressionContext)_localctx).ns = match(IDENT);
setState(2656);
match(COLON);
setState(2659);
switch (_input.LA(1)) {
case IDENT:
{
setState(2657);
((ObserverExpressionContext)_localctx).nm = match(IDENT);
}
break;
case AT:
{
setState(2658);
((ObserverExpressionContext)_localctx).a = match(AT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2661);
match(LPAREN);
setState(2663);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2662);
expressionListWithNamedWithTime();
}
}
setState(2665);
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<TerminalNode> 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, 380, RULE_guardWhereExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2667);
match(IDENT);
setState(2668);
match(COLON);
setState(2669);
match(IDENT);
setState(2670);
match(LPAREN);
setState(2672);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2671);
expressionWithTimeList();
}
}
setState(2674);
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, 382, RULE_guardWhileExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2676);
match(LPAREN);
setState(2677);
expression();
setState(2678);
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<ExpressionContext> 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, 384, RULE_matchUntilRange);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2680);
match(LBRACK);
setState(2690);
switch (_input.LA(1)) {
case WINDOW:
case ESCAPE:
case NOT_EXPR:
case EVERY_EXPR:
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 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 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(2681);
((MatchUntilRangeContext)_localctx).low = expression();
setState(2686);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(2682);
((MatchUntilRangeContext)_localctx).c1 = match(COLON);
setState(2684);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2683);
((MatchUntilRangeContext)_localctx).high = expression();
}
}
}
}
}
break;
case COLON:
{
setState(2688);
((MatchUntilRangeContext)_localctx).c2 = match(COLON);
setState(2689);
((MatchUntilRangeContext)_localctx).upper = expression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2692);
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, 386, RULE_eventFilterExpression);
paraphrases.push("filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2696);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,364,_ctx) ) {
case 1:
{
setState(2694);
((EventFilterExpressionContext)_localctx).i = match(IDENT);
setState(2695);
match(EQUALS);
}
break;
}
setState(2698);
classIdentifier();
setState(2704);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2699);
match(LPAREN);
setState(2701);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2700);
expressionList();
}
}
setState(2703);
match(RPAREN);
}
}
setState(2707);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2706);
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<PropertyExpressionAtomicContext> 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, 388, RULE_propertyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2709);
propertyExpressionAtomic();
setState(2713);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2710);
propertyExpressionAtomic();
}
}
setState(2715);
_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<ExpressionContext> 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, 390, RULE_propertyExpressionAtomic);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2716);
match(LBRACK);
setState(2718);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(2717);
propertyExpressionSelect();
}
}
setState(2720);
expression();
setState(2722);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(2721);
typeExpressionAnnotation();
}
}
setState(2726);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2724);
match(AS);
setState(2725);
((PropertyExpressionAtomicContext)_localctx).n = match(IDENT);
}
}
setState(2730);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2728);
match(WHERE);
setState(2729);
((PropertyExpressionAtomicContext)_localctx).where = expression();
}
}
setState(2732);
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, 392, RULE_propertyExpressionSelect);
try {
enterOuterAlt(_localctx, 1);
{
setState(2734);
match(SELECT);
setState(2735);
propertySelectionList();
setState(2736);
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<PropertySelectionListElementContext> propertySelectionListElement() {
return getRuleContexts(PropertySelectionListElementContext.class);
}
public PropertySelectionListElementContext propertySelectionListElement(int i) {
return getRuleContext(PropertySelectionListElementContext.class,i);
}
public List<TerminalNode> 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, 394, RULE_propertySelectionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2738);
propertySelectionListElement();
setState(2743);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2739);
match(COMMA);
setState(2740);
propertySelectionListElement();
}
}
setState(2745);
_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, 396, RULE_propertySelectionListElement);
int _la;
try {
setState(2753);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,375,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2746);
((PropertySelectionListElementContext)_localctx).s = match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2747);
propertyStreamSelector();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2748);
expression();
setState(2751);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2749);
match(AS);
setState(2750);
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<TerminalNode> 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, 398, RULE_propertyStreamSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2755);
((PropertyStreamSelectorContext)_localctx).s = match(IDENT);
setState(2756);
match(DOT);
setState(2757);
match(STAR);
setState(2760);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2758);
match(AS);
setState(2759);
((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<TerminalNode> 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, 400, RULE_typeExpressionAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(2762);
match(ATCHAR);
setState(2763);
((TypeExpressionAnnotationContext)_localctx).n = match(IDENT);
{
setState(2764);
match(LPAREN);
setState(2765);
((TypeExpressionAnnotationContext)_localctx).v = match(IDENT);
setState(2766);
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, 402, RULE_patternFilterExpression);
paraphrases.push("filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2770);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,377,_ctx) ) {
case 1:
{
setState(2768);
((PatternFilterExpressionContext)_localctx).i = match(IDENT);
setState(2769);
match(EQUALS);
}
break;
}
setState(2772);
classIdentifier();
setState(2778);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2773);
match(LPAREN);
setState(2775);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2774);
expressionList();
}
}
setState(2777);
match(RPAREN);
}
}
setState(2781);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2780);
propertyExpression();
}
}
setState(2784);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(2783);
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, 404, RULE_patternFilterAnnotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2786);
match(ATCHAR);
setState(2787);
((PatternFilterAnnotationContext)_localctx).i = match(IDENT);
setState(2792);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2788);
match(LPAREN);
setState(2789);
number();
setState(2790);
match(RPAREN);
}
}
}
}
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<EscapableStrContext> escapableStr() {
return getRuleContexts(EscapableStrContext.class);
}
public EscapableStrContext escapableStr(int i) {
return getRuleContext(EscapableStrContext.class,i);
}
public List<TerminalNode> 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, 406, RULE_classIdentifier);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2794);
((ClassIdentifierContext)_localctx).i1 = escapableStr();
setState(2799);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,383,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2795);
match(DOT);
setState(2796);
((ClassIdentifierContext)_localctx).i2 = escapableStr();
}
}
}
setState(2801);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,383,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SlashIdentifierContext extends ParserRuleContext {
public Token d;
public EscapableStrContext i1;
public EscapableStrContext i2;
public List<EscapableStrContext> escapableStr() {
return getRuleContexts(EscapableStrContext.class);
}
public EscapableStrContext escapableStr(int i) {
return getRuleContext(EscapableStrContext.class,i);
}
public List<TerminalNode> DIV() { return getTokens(EsperEPL2GrammarParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(EsperEPL2GrammarParser.DIV, i);
}
public SlashIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_slashIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSlashIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSlashIdentifier(this);
}
}
public final SlashIdentifierContext slashIdentifier() throws RecognitionException {
SlashIdentifierContext _localctx = new SlashIdentifierContext(_ctx, getState());
enterRule(_localctx, 408, RULE_slashIdentifier);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2803);
_la = _input.LA(1);
if (_la==DIV) {
{
setState(2802);
((SlashIdentifierContext)_localctx).d = match(DIV);
}
}
setState(2805);
((SlashIdentifierContext)_localctx).i1 = escapableStr();
setState(2810);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,385,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2806);
match(DIV);
setState(2807);
((SlashIdentifierContext)_localctx).i2 = escapableStr();
}
}
}
setState(2812);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,385,_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<ExpressionWithNamedContext> expressionWithNamed() {
return getRuleContexts(ExpressionWithNamedContext.class);
}
public ExpressionWithNamedContext expressionWithNamed(int i) {
return getRuleContext(ExpressionWithNamedContext.class,i);
}
public List<TerminalNode> 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, 410, RULE_expressionListWithNamed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2813);
expressionWithNamed();
setState(2818);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2814);
match(COMMA);
setState(2815);
expressionWithNamed();
}
}
setState(2820);
_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<ExpressionWithNamedWithTimeContext> expressionWithNamedWithTime() {
return getRuleContexts(ExpressionWithNamedWithTimeContext.class);
}
public ExpressionWithNamedWithTimeContext expressionWithNamedWithTime(int i) {
return getRuleContext(ExpressionWithNamedWithTimeContext.class,i);
}
public List<TerminalNode> 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, 412, RULE_expressionListWithNamedWithTime);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2821);
expressionWithNamedWithTime();
setState(2826);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2822);
match(COMMA);
setState(2823);
expressionWithNamedWithTime();
}
}
setState(2828);
_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, 414, RULE_expressionWithNamed);
try {
setState(2831);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,388,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2829);
expressionNamedParameter();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2830);
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, 416, RULE_expressionWithNamedWithTime);
try {
setState(2835);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,389,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2833);
expressionNamedParameterWithTime();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2834);
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, 418, RULE_expressionNamedParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2837);
match(IDENT);
setState(2838);
match(COLON);
setState(2845);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,391,_ctx) ) {
case 1:
{
setState(2839);
expression();
}
break;
case 2:
{
setState(2840);
match(LPAREN);
setState(2842);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2841);
expressionList();
}
}
setState(2844);
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, 420, RULE_expressionNamedParameterWithTime);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2847);
match(IDENT);
setState(2848);
match(COLON);
setState(2855);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) {
case 1:
{
setState(2849);
expressionWithTime();
}
break;
case 2:
{
setState(2850);
match(LPAREN);
setState(2852);
_la = _input.LA(1);
if (((((_la - 2)) & ~0x3f) == 0 && ((1L << (_la - 2)) & ((1L << (WINDOW - 2)) | (1L << (ESCAPE - 2)) | (1L << (NOT_EXPR - 2)) | (1L << (EVERY_EXPR - 2)) | (1L << (SUM - 2)) | (1L << (AVG - 2)) | (1L << (MAX - 2)) | (1L << (MIN - 2)) | (1L << (COALESCE - 2)) | (1L << (MEDIAN - 2)) | (1L << (STDDEV - 2)) | (1L << (AVEDEV - 2)) | (1L << (COUNT - 2)) | (1L << (CASE - 2)) | (1L << (OUTER - 2)) | (1L << (JOIN - 2)) | (1L << (LEFT - 2)) | (1L << (RIGHT - 2)) | (1L << (FULL - 2)) | (1L << (EVENTS - 2)) | (1L << (FIRST - 2)) | (1L << (LAST - 2)) | (1L << (ISTREAM - 2)) | (1L << (SCHEMA - 2)) | (1L << (UNIDIRECTIONAL - 2)) | (1L << (RETAINUNION - 2)) | (1L << (RETAININTERSECTION - 2)) | (1L << (PATTERN - 2)) | (1L << (SQL - 2)) | (1L << (METADATASQL - 2)))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (PREVIOUS - 66)) | (1L << (PREVIOUSTAIL - 66)) | (1L << (PREVIOUSCOUNT - 66)) | (1L << (PREVIOUSWINDOW - 66)) | (1L << (PRIOR - 66)) | (1L << (EXISTS - 66)) | (1L << (WEEKDAY - 66)) | (1L << (LW - 66)) | (1L << (INSTANCEOF - 66)) | (1L << (TYPEOF - 66)) | (1L << (CAST - 66)) | (1L << (CURRENT_TIMESTAMP - 66)) | (1L << (SNAPSHOT - 66)) | (1L << (VARIABLE - 66)) | (1L << (TABLE - 66)) | (1L << (UNTIL - 66)) | (1L << (AT - 66)) | (1L << (INDEX - 66)) | (1L << (BOOLEAN_TRUE - 66)) | (1L << (BOOLEAN_FALSE - 66)) | (1L << (VALUE_NULL - 66)) | (1L << (DEFINE - 66)) | (1L << (PARTITION - 66)) | (1L << (MATCHES - 66)) | (1L << (FOR - 66)) | (1L << (WHILE - 66)) | (1L << (USING - 66)) | (1L << (MERGE - 66)) | (1L << (MATCHED - 66)) | (1L << (NEWKW - 66)) | (1L << (CONTEXT - 66)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (GROUPING - 134)) | (1L << (GROUPING_ID - 134)) | (1L << (QUESTION - 134)) | (1L << (LPAREN - 134)) | (1L << (LBRACK - 134)) | (1L << (LCURLY - 134)) | (1L << (PLUS - 134)) | (1L << (MINUS - 134)) | (1L << (STAR - 134)) | (1L << (TICKED_STRING_LITERAL - 134)) | (1L << (QUOTED_STRING_LITERAL - 134)) | (1L << (STRING_LITERAL - 134)) | (1L << (IDENT - 134)) | (1L << (IntegerLiteral - 134)) | (1L << (FloatingPointLiteral - 134)))) != 0)) {
{
setState(2851);
expressionWithTimeList();
}
}
setState(2854);
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<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<TerminalNode> 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, 422, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2857);
expression();
setState(2862);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2858);
match(COMMA);
setState(2859);
expression();
}
}
setState(2864);
_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<ExpressionWithTimeInclLastContext> expressionWithTimeInclLast() {
return getRuleContexts(ExpressionWithTimeInclLastContext.class);
}
public ExpressionWithTimeInclLastContext expressionWithTimeInclLast(int i) {
return getRuleContext(ExpressionWithTimeInclLastContext.class,i);
}
public List<TerminalNode> 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, 424, RULE_expressionWithTimeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2865);
expressionWithTimeInclLast();
setState(2870);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2866);
match(COMMA);
setState(2867);
expressionWithTimeInclLast();
}
}
setState(2872);
_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, 426, RULE_expressionWithTime);
try {
setState(2883);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,396,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2873);
lastWeekdayOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2874);
timePeriod();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2875);
expressionQualifyable();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2876);
rangeOperand();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2877);
frequencyOperand();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2878);
lastOperator();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2879);
weekDayOperator();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2880);
numericParameterList();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2881);
match(STAR);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2882);
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, 428, RULE_expressionWithTimeInclLast);
try {
setState(2887);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,397,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2885);
lastOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2886);
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, 430, RULE_expressionQualifyable);
try {
enterOuterAlt(_localctx, 1);
{
setState(2889);
expression();
setState(2895);
switch (_input.LA(1)) {
case ASC:
{
setState(2890);
((ExpressionQualifyableContext)_localctx).a = match(ASC);
}
break;
case DESC:
{
setState(2891);
((ExpressionQualifyableContext)_localctx).d = match(DESC);
}
break;
case TIMEPERIOD_SECONDS:
{
setState(2892);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SECONDS);
}
break;
case TIMEPERIOD_SECOND:
{
setState(2893);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SECOND);
}
break;
case TIMEPERIOD_SEC:
{
setState(2894);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SEC);
}
break;
case RPAREN:
case 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 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, 432, RULE_lastWeekdayOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2897);
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, 434, RULE_lastOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2899);
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, 436, RULE_frequencyOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2901);
match(STAR);
setState(2902);
match(DIV);
setState(2906);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2903);
number();
}
break;
case IDENT:
{
setState(2904);
((FrequencyOperandContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2905);
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<NumberContext> number() {
return getRuleContexts(NumberContext.class);
}
public NumberContext number(int i) {
return getRuleContext(NumberContext.class,i);
}
public List<TerminalNode> IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List<SubstitutionContext> 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, 438, RULE_rangeOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2911);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2908);
((RangeOperandContext)_localctx).n1 = number();
}
break;
case IDENT:
{
setState(2909);
((RangeOperandContext)_localctx).i1 = match(IDENT);
}
break;
case QUESTION:
{
setState(2910);
((RangeOperandContext)_localctx).s1 = substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2913);
match(COLON);
setState(2917);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2914);
((RangeOperandContext)_localctx).n2 = number();
}
break;
case IDENT:
{
setState(2915);
((RangeOperandContext)_localctx).i2 = match(IDENT);
}
break;
case QUESTION:
{
setState(2916);
((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, 440, RULE_lastOperator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2922);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2919);
number();
}
break;
case IDENT:
{
setState(2920);
((LastOperatorContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2921);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2924);
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, 442, RULE_weekDayOperator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2929);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2926);
number();
}
break;
case IDENT:
{
setState(2927);
((WeekDayOperatorContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2928);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2931);
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<NumericListParameterContext> 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<TerminalNode> 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, 444, RULE_numericParameterList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2933);
match(LBRACK);
setState(2934);
numericListParameter();
setState(2939);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2935);
match(COMMA);
setState(2936);
numericListParameter();
}
}
setState(2941);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2942);
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, 446, RULE_numericListParameter);
try {
setState(2947);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,405,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2944);
rangeOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2945);
frequencyOperand();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2946);
numberconstant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EventPropertyContext extends ParserRuleContext {
public List<EventPropertyAtomicContext> eventPropertyAtomic() {
return getRuleContexts(EventPropertyAtomicContext.class);
}
public EventPropertyAtomicContext eventPropertyAtomic(int i) {
return getRuleContext(EventPropertyAtomicContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public EventPropertyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eventProperty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEventProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEventProperty(this);
}
}
public final EventPropertyContext eventProperty() throws RecognitionException {
EventPropertyContext _localctx = new EventPropertyContext(_ctx, getState());
enterRule(_localctx, 448, RULE_eventProperty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2949);
eventPropertyAtomic();
setState(2954);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2950);
match(DOT);
setState(2951);
eventPropertyAtomic();
}
}
setState(2956);
_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 EventPropertyAtomicContext extends ParserRuleContext {
public Token lb;
public NumberContext ni;
public Token q;
public Token lp;
public Token s;
public Token q1;
public EventPropertyIdentContext eventPropertyIdent() {
return getRuleContext(EventPropertyIdentContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public TerminalNode STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.STRING_LITERAL, 0); }
public TerminalNode QUOTED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.QUOTED_STRING_LITERAL, 0); }
public EventPropertyAtomicContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eventPropertyAtomic; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEventPropertyAtomic(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEventPropertyAtomic(this);
}
}
public final EventPropertyAtomicContext eventPropertyAtomic() throws RecognitionException {
EventPropertyAtomicContext _localctx = new EventPropertyAtomicContext(_ctx, getState());
enterRule(_localctx, 450, RULE_eventPropertyAtomic);
try {
enterOuterAlt(_localctx, 1);
{
setState(2957);
eventPropertyIdent();
setState(2974);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,410,_ctx) ) {
case 1:
{
setState(2958);
((EventPropertyAtomicContext)_localctx).lb = match(LBRACK);
setState(2959);
((EventPropertyAtomicContext)_localctx).ni = number();
setState(2960);
match(RBRACK);
setState(2962);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,407,_ctx) ) {
case 1:
{
setState(2961);
((EventPropertyAtomicContext)_localctx).q = match(QUESTION);
}
break;
}
}
break;
case 2:
{
setState(2964);
((EventPropertyAtomicContext)_localctx).lp = match(LPAREN);
setState(2967);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(2965);
((EventPropertyAtomicContext)_localctx).s = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(2966);
((EventPropertyAtomicContext)_localctx).s = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2969);
match(RPAREN);
setState(2971);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,409,_ctx) ) {
case 1:
{
setState(2970);
((EventPropertyAtomicContext)_localctx).q = match(QUESTION);
}
break;
}
}
break;
case 3:
{
setState(2973);
((EventPropertyAtomicContext)_localctx).q1 = match(QUESTION);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EventPropertyIdentContext extends ParserRuleContext {
public KeywordAllowedIdentContext ipi;
public KeywordAllowedIdentContext ipi2;
public List<KeywordAllowedIdentContext> keywordAllowedIdent() {
return getRuleContexts(KeywordAllowedIdentContext.class);
}
public KeywordAllowedIdentContext keywordAllowedIdent(int i) {
return getRuleContext(KeywordAllowedIdentContext.class,i);
}
public List<TerminalNode> ESCAPECHAR() { return getTokens(EsperEPL2GrammarParser.ESCAPECHAR); }
public TerminalNode ESCAPECHAR(int i) {
return getToken(EsperEPL2GrammarParser.ESCAPECHAR, i);
}
public List<TerminalNode> DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public EventPropertyIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eventPropertyIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEventPropertyIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEventPropertyIdent(this);
}
}
public final EventPropertyIdentContext eventPropertyIdent() throws RecognitionException {
EventPropertyIdentContext _localctx = new EventPropertyIdentContext(_ctx, getState());
enterRule(_localctx, 452, RULE_eventPropertyIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2976);
((EventPropertyIdentContext)_localctx).ipi = keywordAllowedIdent();
setState(2984);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ESCAPECHAR) {
{
{
setState(2977);
match(ESCAPECHAR);
setState(2978);
match(DOT);
setState(2980);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,411,_ctx) ) {
case 1:
{
setState(2979);
((EventPropertyIdentContext)_localctx).ipi2 = keywordAllowedIdent();
}
break;
}
}
}
setState(2986);
_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 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 AT() { return getToken(EsperEPL2GrammarParser.AT, 0); }
public TerminalNode COUNT() { return getToken(EsperEPL2GrammarParser.COUNT, 0); }
public TerminalNode ESCAPE() { return getToken(EsperEPL2GrammarParser.ESCAPE, 0); }
public TerminalNode EVERY_EXPR() { return getToken(EsperEPL2GrammarParser.EVERY_EXPR, 0); }
public TerminalNode SCHEMA() { return getToken(EsperEPL2GrammarParser.SCHEMA, 0); }
public TerminalNode SUM() { return getToken(EsperEPL2GrammarParser.SUM, 0); }
public TerminalNode AVG() { return getToken(EsperEPL2GrammarParser.AVG, 0); }
public TerminalNode MAX() { return getToken(EsperEPL2GrammarParser.MAX, 0); }
public TerminalNode MIN() { return getToken(EsperEPL2GrammarParser.MIN, 0); }
public TerminalNode COALESCE() { return getToken(EsperEPL2GrammarParser.COALESCE, 0); }
public TerminalNode MEDIAN() { return getToken(EsperEPL2GrammarParser.MEDIAN, 0); }
public TerminalNode STDDEV() { return getToken(EsperEPL2GrammarParser.STDDEV, 0); }
public TerminalNode AVEDEV() { return getToken(EsperEPL2GrammarParser.AVEDEV, 0); }
public TerminalNode EVENTS() { return getToken(EsperEPL2GrammarParser.EVENTS, 0); }
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(EsperEPL2GrammarParser.LAST, 0); }
public TerminalNode WHILE() { return getToken(EsperEPL2GrammarParser.WHILE, 0); }
public TerminalNode MERGE() { return getToken(EsperEPL2GrammarParser.MERGE, 0); }
public TerminalNode MATCHED() { return getToken(EsperEPL2GrammarParser.MATCHED, 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 TerminalNode UNTIL() { return getToken(EsperEPL2GrammarParser.UNTIL, 0); }
public TerminalNode PATTERN() { return getToken(EsperEPL2GrammarParser.PATTERN, 0); }
public TerminalNode SQL() { return getToken(EsperEPL2GrammarParser.SQL, 0); }
public TerminalNode METADATASQL() { return getToken(EsperEPL2GrammarParser.METADATASQL, 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 WEEKDAY() { return getToken(EsperEPL2GrammarParser.WEEKDAY, 0); }
public TerminalNode LW() { return getToken(EsperEPL2GrammarParser.LW, 0); }
public TerminalNode INSTANCEOF() { return getToken(EsperEPL2GrammarParser.INSTANCEOF, 0); }
public TerminalNode TYPEOF() { return getToken(EsperEPL2GrammarParser.TYPEOF, 0); }
public TerminalNode CAST() { return getToken(EsperEPL2GrammarParser.CAST, 0); }
public TerminalNode SNAPSHOT() { return getToken(EsperEPL2GrammarParser.SNAPSHOT, 0); }
public TerminalNode VARIABLE() { return getToken(EsperEPL2GrammarParser.VARIABLE, 0); }
public TerminalNode TABLE() { return getToken(EsperEPL2GrammarParser.TABLE, 0); }
public TerminalNode INDEX() { return getToken(EsperEPL2GrammarParser.INDEX, 0); }
public TerminalNode WINDOW() { return getToken(EsperEPL2GrammarParser.WINDOW, 0); }
public TerminalNode LEFT() { return getToken(EsperEPL2GrammarParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(EsperEPL2GrammarParser.RIGHT, 0); }
public TerminalNode OUTER() { return getToken(EsperEPL2GrammarParser.OUTER, 0); }
public TerminalNode FULL() { return getToken(EsperEPL2GrammarParser.FULL, 0); }
public TerminalNode JOIN() { return getToken(EsperEPL2GrammarParser.JOIN, 0); }
public TerminalNode DEFINE() { return getToken(EsperEPL2GrammarParser.DEFINE, 0); }
public TerminalNode PARTITION() { return getToken(EsperEPL2GrammarParser.PARTITION, 0); }
public TerminalNode MATCHES() { return getToken(EsperEPL2GrammarParser.MATCHES, 0); }
public TerminalNode CONTEXT() { return getToken(EsperEPL2GrammarParser.CONTEXT, 0); }
public TerminalNode FOR() { return getToken(EsperEPL2GrammarParser.FOR, 0); }
public TerminalNode USING() { return getToken(EsperEPL2GrammarParser.USING, 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, 454, RULE_keywordAllowedIdent);
try {
setState(3039);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2987);
((KeywordAllowedIdentContext)_localctx).i1 = match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(2988);
((KeywordAllowedIdentContext)_localctx).i2 = match(TICKED_STRING_LITERAL);
}
break;
case AT:
enterOuterAlt(_localctx, 3);
{
setState(2989);
match(AT);
}
break;
case COUNT:
enterOuterAlt(_localctx, 4);
{
setState(2990);
match(COUNT);
}
break;
case ESCAPE:
enterOuterAlt(_localctx, 5);
{
setState(2991);
match(ESCAPE);
}
break;
case EVERY_EXPR:
enterOuterAlt(_localctx, 6);
{
setState(2992);
match(EVERY_EXPR);
}
break;
case SCHEMA:
enterOuterAlt(_localctx, 7);
{
setState(2993);
match(SCHEMA);
}
break;
case SUM:
enterOuterAlt(_localctx, 8);
{
setState(2994);
match(SUM);
}
break;
case AVG:
enterOuterAlt(_localctx, 9);
{
setState(2995);
match(AVG);
}
break;
case MAX:
enterOuterAlt(_localctx, 10);
{
setState(2996);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 11);
{
setState(2997);
match(MIN);
}
break;
case COALESCE:
enterOuterAlt(_localctx, 12);
{
setState(2998);
match(COALESCE);
}
break;
case MEDIAN:
enterOuterAlt(_localctx, 13);
{
setState(2999);
match(MEDIAN);
}
break;
case STDDEV:
enterOuterAlt(_localctx, 14);
{
setState(3000);
match(STDDEV);
}
break;
case AVEDEV:
enterOuterAlt(_localctx, 15);
{
setState(3001);
match(AVEDEV);
}
break;
case EVENTS:
enterOuterAlt(_localctx, 16);
{
setState(3002);
match(EVENTS);
}
break;
case FIRST:
enterOuterAlt(_localctx, 17);
{
setState(3003);
match(FIRST);
}
break;
case LAST:
enterOuterAlt(_localctx, 18);
{
setState(3004);
match(LAST);
}
break;
case WHILE:
enterOuterAlt(_localctx, 19);
{
setState(3005);
match(WHILE);
}
break;
case MERGE:
enterOuterAlt(_localctx, 20);
{
setState(3006);
match(MERGE);
}
break;
case MATCHED:
enterOuterAlt(_localctx, 21);
{
setState(3007);
match(MATCHED);
}
break;
case UNIDIRECTIONAL:
enterOuterAlt(_localctx, 22);
{
setState(3008);
match(UNIDIRECTIONAL);
}
break;
case RETAINUNION:
enterOuterAlt(_localctx, 23);
{
setState(3009);
match(RETAINUNION);
}
break;
case RETAININTERSECTION:
enterOuterAlt(_localctx, 24);
{
setState(3010);
match(RETAININTERSECTION);
}
break;
case UNTIL:
enterOuterAlt(_localctx, 25);
{
setState(3011);
match(UNTIL);
}
break;
case PATTERN:
enterOuterAlt(_localctx, 26);
{
setState(3012);
match(PATTERN);
}
break;
case SQL:
enterOuterAlt(_localctx, 27);
{
setState(3013);
match(SQL);
}
break;
case METADATASQL:
enterOuterAlt(_localctx, 28);
{
setState(3014);
match(METADATASQL);
}
break;
case PREVIOUS:
enterOuterAlt(_localctx, 29);
{
setState(3015);
match(PREVIOUS);
}
break;
case PREVIOUSTAIL:
enterOuterAlt(_localctx, 30);
{
setState(3016);
match(PREVIOUSTAIL);
}
break;
case PRIOR:
enterOuterAlt(_localctx, 31);
{
setState(3017);
match(PRIOR);
}
break;
case WEEKDAY:
enterOuterAlt(_localctx, 32);
{
setState(3018);
match(WEEKDAY);
}
break;
case LW:
enterOuterAlt(_localctx, 33);
{
setState(3019);
match(LW);
}
break;
case INSTANCEOF:
enterOuterAlt(_localctx, 34);
{
setState(3020);
match(INSTANCEOF);
}
break;
case TYPEOF:
enterOuterAlt(_localctx, 35);
{
setState(3021);
match(TYPEOF);
}
break;
case CAST:
enterOuterAlt(_localctx, 36);
{
setState(3022);
match(CAST);
}
break;
case SNAPSHOT:
enterOuterAlt(_localctx, 37);
{
setState(3023);
match(SNAPSHOT);
}
break;
case VARIABLE:
enterOuterAlt(_localctx, 38);
{
setState(3024);
match(VARIABLE);
}
break;
case TABLE:
enterOuterAlt(_localctx, 39);
{
setState(3025);
match(TABLE);
}
break;
case INDEX:
enterOuterAlt(_localctx, 40);
{
setState(3026);
match(INDEX);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 41);
{
setState(3027);
match(WINDOW);
}
break;
case LEFT:
enterOuterAlt(_localctx, 42);
{
setState(3028);
match(LEFT);
}
break;
case RIGHT:
enterOuterAlt(_localctx, 43);
{
setState(3029);
match(RIGHT);
}
break;
case OUTER:
enterOuterAlt(_localctx, 44);
{
setState(3030);
match(OUTER);
}
break;
case FULL:
enterOuterAlt(_localctx, 45);
{
setState(3031);
match(FULL);
}
break;
case JOIN:
enterOuterAlt(_localctx, 46);
{
setState(3032);
match(JOIN);
}
break;
case DEFINE:
enterOuterAlt(_localctx, 47);
{
setState(3033);
match(DEFINE);
}
break;
case PARTITION:
enterOuterAlt(_localctx, 48);
{
setState(3034);
match(PARTITION);
}
break;
case MATCHES:
enterOuterAlt(_localctx, 49);
{
setState(3035);
match(MATCHES);
}
break;
case CONTEXT:
enterOuterAlt(_localctx, 50);
{
setState(3036);
match(CONTEXT);
}
break;
case FOR:
enterOuterAlt(_localctx, 51);
{
setState(3037);
match(FOR);
}
break;
case USING:
enterOuterAlt(_localctx, 52);
{
setState(3038);
match(USING);
}
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, 456, RULE_escapableStr);
try {
setState(3044);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3041);
((EscapableStrContext)_localctx).i1 = match(IDENT);
}
break;
case EVENTS:
enterOuterAlt(_localctx, 2);
{
setState(3042);
((EscapableStrContext)_localctx).i2 = match(EVENTS);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(3043);
((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, 458, RULE_escapableIdent);
try {
setState(3048);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3046);
match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3047);
((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, 460, RULE_timePeriod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3167);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,452,_ctx) ) {
case 1:
{
setState(3050);
yearPart();
setState(3052);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,416,_ctx) ) {
case 1:
{
setState(3051);
monthPart();
}
break;
}
setState(3055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,417,_ctx) ) {
case 1:
{
setState(3054);
weekPart();
}
break;
}
setState(3058);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,418,_ctx) ) {
case 1:
{
setState(3057);
dayPart();
}
break;
}
setState(3061);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,419,_ctx) ) {
case 1:
{
setState(3060);
hourPart();
}
break;
}
setState(3064);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,420,_ctx) ) {
case 1:
{
setState(3063);
minutePart();
}
break;
}
setState(3067);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) {
case 1:
{
setState(3066);
secondPart();
}
break;
}
setState(3070);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) {
case 1:
{
setState(3069);
millisecondPart();
}
break;
}
setState(3073);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3072);
microsecondPart();
}
}
}
break;
case 2:
{
setState(3075);
monthPart();
setState(3077);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,424,_ctx) ) {
case 1:
{
setState(3076);
weekPart();
}
break;
}
setState(3080);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,425,_ctx) ) {
case 1:
{
setState(3079);
dayPart();
}
break;
}
setState(3083);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,426,_ctx) ) {
case 1:
{
setState(3082);
hourPart();
}
break;
}
setState(3086);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,427,_ctx) ) {
case 1:
{
setState(3085);
minutePart();
}
break;
}
setState(3089);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,428,_ctx) ) {
case 1:
{
setState(3088);
secondPart();
}
break;
}
setState(3092);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,429,_ctx) ) {
case 1:
{
setState(3091);
millisecondPart();
}
break;
}
setState(3095);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3094);
microsecondPart();
}
}
}
break;
case 3:
{
setState(3097);
weekPart();
setState(3099);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,431,_ctx) ) {
case 1:
{
setState(3098);
dayPart();
}
break;
}
setState(3102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,432,_ctx) ) {
case 1:
{
setState(3101);
hourPart();
}
break;
}
setState(3105);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,433,_ctx) ) {
case 1:
{
setState(3104);
minutePart();
}
break;
}
setState(3108);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,434,_ctx) ) {
case 1:
{
setState(3107);
secondPart();
}
break;
}
setState(3111);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,435,_ctx) ) {
case 1:
{
setState(3110);
millisecondPart();
}
break;
}
setState(3114);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3113);
microsecondPart();
}
}
}
break;
case 4:
{
setState(3116);
dayPart();
setState(3118);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,437,_ctx) ) {
case 1:
{
setState(3117);
hourPart();
}
break;
}
setState(3121);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,438,_ctx) ) {
case 1:
{
setState(3120);
minutePart();
}
break;
}
setState(3124);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,439,_ctx) ) {
case 1:
{
setState(3123);
secondPart();
}
break;
}
setState(3127);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,440,_ctx) ) {
case 1:
{
setState(3126);
millisecondPart();
}
break;
}
setState(3130);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3129);
microsecondPart();
}
}
}
break;
case 5:
{
setState(3132);
hourPart();
setState(3134);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,442,_ctx) ) {
case 1:
{
setState(3133);
minutePart();
}
break;
}
setState(3137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,443,_ctx) ) {
case 1:
{
setState(3136);
secondPart();
}
break;
}
setState(3140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,444,_ctx) ) {
case 1:
{
setState(3139);
millisecondPart();
}
break;
}
setState(3143);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3142);
microsecondPart();
}
}
}
break;
case 6:
{
setState(3145);
minutePart();
setState(3147);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,446,_ctx) ) {
case 1:
{
setState(3146);
secondPart();
}
break;
}
setState(3150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,447,_ctx) ) {
case 1:
{
setState(3149);
millisecondPart();
}
break;
}
setState(3153);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3152);
microsecondPart();
}
}
}
break;
case 7:
{
setState(3155);
secondPart();
setState(3157);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,449,_ctx) ) {
case 1:
{
setState(3156);
millisecondPart();
}
break;
}
setState(3160);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3159);
microsecondPart();
}
}
}
break;
case 8:
{
setState(3162);
millisecondPart();
setState(3164);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (MINUS - 143)) | (1L << (IDENT - 143)) | (1L << (IntegerLiteral - 143)) | (1L << (FloatingPointLiteral - 143)))) != 0)) {
{
setState(3163);
microsecondPart();
}
}
}
break;
case 9:
{
setState(3166);
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, 462, RULE_yearPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3172);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3169);
numberconstant();
}
break;
case IDENT:
{
setState(3170);
((YearPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3171);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3174);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_YEAR || _la==TIMEPERIOD_YEARS) ) {
_errHandler.recoverInline(this);
} else {
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, 464, RULE_monthPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3179);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3176);
numberconstant();
}
break;
case IDENT:
{
setState(3177);
((MonthPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3178);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3181);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_MONTH || _la==TIMEPERIOD_MONTHS) ) {
_errHandler.recoverInline(this);
} else {
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, 466, RULE_weekPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3186);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3183);
numberconstant();
}
break;
case IDENT:
{
setState(3184);
((WeekPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3185);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3188);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_WEEK || _la==TIMEPERIOD_WEEKS) ) {
_errHandler.recoverInline(this);
} else {
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, 468, RULE_dayPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3193);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3190);
numberconstant();
}
break;
case IDENT:
{
setState(3191);
((DayPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3192);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3195);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_DAY || _la==TIMEPERIOD_DAYS) ) {
_errHandler.recoverInline(this);
} else {
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, 470, RULE_hourPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3200);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3197);
numberconstant();
}
break;
case IDENT:
{
setState(3198);
((HourPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3199);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3202);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_HOUR || _la==TIMEPERIOD_HOURS) ) {
_errHandler.recoverInline(this);
} else {
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, 472, RULE_minutePart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3207);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3204);
numberconstant();
}
break;
case IDENT:
{
setState(3205);
((MinutePartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3206);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3209);
_la = _input.LA(1);
if ( !(_la==MIN || _la==TIMEPERIOD_MINUTE || _la==TIMEPERIOD_MINUTES) ) {
_errHandler.recoverInline(this);
} else {
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, 474, RULE_secondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3214);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3211);
numberconstant();
}
break;
case IDENT:
{
setState(3212);
((SecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3213);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3216);
_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 {
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, 476, RULE_millisecondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3221);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3218);
numberconstant();
}
break;
case IDENT:
{
setState(3219);
((MillisecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3220);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3223);
_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 {
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, 478, RULE_microsecondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3228);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3225);
numberconstant();
}
break;
case IDENT:
{
setState(3226);
((MicrosecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3227);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3230);
_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 {
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, 480, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3232);
_la = _input.LA(1);
if ( !(_la==IntegerLiteral || _la==FloatingPointLiteral) ) {
_errHandler.recoverInline(this);
} else {
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 TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public SlashIdentifierContext slashIdentifier() {
return getRuleContext(SlashIdentifierContext.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, 482, RULE_substitution);
try {
enterOuterAlt(_localctx, 1);
{
setState(3234);
((SubstitutionContext)_localctx).q = match(QUESTION);
setState(3237);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,462,_ctx) ) {
case 1:
{
setState(3235);
match(COLON);
setState(3236);
slashIdentifier();
}
break;
}
}
}
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, 484, RULE_constant);
try {
setState(3244);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 1);
{
setState(3239);
numberconstant();
}
break;
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3240);
stringconstant();
}
break;
case BOOLEAN_TRUE:
enterOuterAlt(_localctx, 3);
{
setState(3241);
((ConstantContext)_localctx).t = match(BOOLEAN_TRUE);
}
break;
case BOOLEAN_FALSE:
enterOuterAlt(_localctx, 4);
{
setState(3242);
((ConstantContext)_localctx).f = match(BOOLEAN_FALSE);
}
break;
case VALUE_NULL:
enterOuterAlt(_localctx, 5);
{
setState(3243);
((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, 486, RULE_numberconstant);
try {
enterOuterAlt(_localctx, 1);
{
setState(3248);
switch (_input.LA(1)) {
case MINUS:
{
setState(3246);
((NumberconstantContext)_localctx).m = match(MINUS);
}
break;
case PLUS:
{
setState(3247);
((NumberconstantContext)_localctx).p = match(PLUS);
}
break;
case IntegerLiteral:
case FloatingPointLiteral:
break;
default:
throw new NoViableAltException(this);
}
setState(3250);
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, 488, RULE_stringconstant);
try {
setState(3254);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(3252);
((StringconstantContext)_localctx).sl = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3253);
((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, 490, RULE_jsonvalue);
try {
setState(3259);
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(3256);
constant();
}
break;
case LCURLY:
enterOuterAlt(_localctx, 2);
{
setState(3257);
jsonobject();
}
break;
case LBRACK:
enterOuterAlt(_localctx, 3);
{
setState(3258);
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, 492, RULE_jsonobject);
try {
enterOuterAlt(_localctx, 1);
{
setState(3261);
match(LCURLY);
setState(3262);
jsonmembers();
setState(3263);
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, 494, RULE_jsonarray);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3265);
match(LBRACK);
setState(3267);
_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 - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(3266);
jsonelements();
}
}
setState(3269);
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<JsonvalueContext> jsonvalue() {
return getRuleContexts(JsonvalueContext.class);
}
public JsonvalueContext jsonvalue(int i) {
return getRuleContext(JsonvalueContext.class,i);
}
public List<TerminalNode> 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, 496, RULE_jsonelements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3271);
jsonvalue();
setState(3276);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,468,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3272);
match(COMMA);
setState(3273);
jsonvalue();
}
}
}
setState(3278);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,468,_ctx);
}
setState(3280);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(3279);
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<JsonpairContext> jsonpair() {
return getRuleContexts(JsonpairContext.class);
}
public JsonpairContext jsonpair(int i) {
return getRuleContext(JsonpairContext.class,i);
}
public List<TerminalNode> 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, 498, RULE_jsonmembers);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3282);
jsonpair();
setState(3287);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,470,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3283);
match(COMMA);
setState(3284);
jsonpair();
}
}
}
setState(3289);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,470,_ctx);
}
setState(3291);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(3290);
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, 500, RULE_jsonpair);
try {
enterOuterAlt(_localctx, 1);
{
setState(3295);
switch (_input.LA(1)) {
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
{
setState(3293);
stringconstant();
}
break;
case WINDOW:
case ESCAPE:
case EVERY_EXPR:
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 VARIABLE:
case TABLE:
case UNTIL:
case AT:
case INDEX:
case DEFINE:
case PARTITION:
case MATCHES:
case FOR:
case WHILE:
case USING:
case MERGE:
case MATCHED:
case CONTEXT:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(3294);
keywordAllowedIdent();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3297);
match(COLON);
setState(3298);
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\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u00c7\u0ce7\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\3\2\3\2\7\2\u01fb\n\2\f\2\16"+
"\2\u01fe\13\2\3\2\3\2\3\2\3\3\3\3\7\3\u0205\n\3\f\3\16\3\u0208\13\3\3"+
"\3\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\5\6\u0215\n\6\3\6\3\6\5\6\u0219"+
"\n\6\3\6\5\6\u021c\n\6\3\6\5\6\u021f\n\6\3\6\3\6\3\6\5\6\u0224\n\6\3\6"+
"\5\6\u0227\n\6\3\6\3\6\5\6\u022b\n\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\5\b\u0234"+
"\n\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u023d\n\b\3\t\3\t\3\t\3\t\3\t\5\t"+
"\u0244\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\u0253\n\13\3\13\5\13\u0256\n\13\3\f\3\f\3\f\7\f\u025b\n\f\f\f\16\f"+
"\u025e\13\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\5\16\u0269\n\16\3"+
"\17\3\17\3\17\3\17\7\17\u026f\n\17\f\17\16\17\u0272\13\17\5\17\u0274\n"+
"\17\3\17\5\17\u0277\n\17\3\17\3\17\3\20\5\20\u027c\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\5\20\u028c\n\20"+
"\3\20\5\20\u028f\n\20\3\21\3\21\3\21\3\22\3\22\5\22\u0296\n\22\3\22\3"+
"\22\5\22\u029a\n\22\3\22\3\22\3\22\3\22\5\22\u02a0\n\22\3\22\5\22\u02a3"+
"\n\22\3\22\3\22\5\22\u02a7\n\22\3\22\3\22\3\22\5\22\u02ac\n\22\3\22\3"+
"\22\5\22\u02b0\n\22\3\22\3\22\5\22\u02b4\n\22\3\22\3\22\3\22\5\22\u02b9"+
"\n\22\3\22\3\22\5\22\u02bd\n\22\3\23\3\23\3\23\3\23\3\23\6\23\u02c4\n"+
"\23\r\23\16\23\u02c5\3\23\5\23\u02c9\n\23\5\23\u02cb\n\23\3\23\3\23\3"+
"\23\5\23\u02d0\n\23\3\24\3\24\5\24\u02d4\n\24\3\24\3\24\3\24\5\24\u02d9"+
"\n\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\5\26\u02e3\n\26\3\26\3\26"+
"\3\26\3\26\5\26\u02e9\n\26\3\27\3\27\5\27\u02ed\n\27\3\27\3\27\3\27\3"+
"\27\5\27\u02f3\n\27\3\27\3\27\5\27\u02f7\n\27\3\27\6\27\u02fa\n\27\r\27"+
"\16\27\u02fb\3\30\3\30\5\30\u0300\n\30\3\31\3\31\3\31\3\31\5\31\u0306"+
"\n\31\3\31\6\31\u0309\n\31\r\31\16\31\u030a\3\32\3\32\3\32\3\32\3\32\3"+
"\32\3\32\5\32\u0314\n\32\3\32\3\32\3\32\5\32\u0319\n\32\3\32\5\32\u031c"+
"\n\32\3\33\3\33\3\33\3\33\3\33\5\33\u0323\n\33\3\33\6\33\u0326\n\33\r"+
"\33\16\33\u0327\3\34\3\34\3\34\3\35\3\35\3\35\5\35\u0330\n\35\3\35\3\35"+
"\3\35\3\35\5\35\u0336\n\35\3\35\3\35\3\35\3\35\5\35\u033c\n\35\3\36\3"+
"\36\5\36\u0340\n\36\3\36\3\36\5\36\u0344\n\36\3\36\5\36\u0347\n\36\3\36"+
"\5\36\u034a\n\36\3\36\3\36\5\36\u034e\n\36\3\36\3\36\5\36\u0352\n\36\3"+
"\36\3\36\3\36\5\36\u0357\n\36\3\36\3\36\5\36\u035b\n\36\3\36\3\36\3\36"+
"\5\36\u0360\n\36\3\36\3\36\5\36\u0364\n\36\3\37\3\37\3\37\3\37\3\37\5"+
"\37\u036b\n\37\3\37\3\37\3\37\3\37\5\37\u0371\n\37\3 \3 \3 \3 \3 \5 \u0378"+
"\n \3 \3 \5 \u037c\n \3!\3!\3!\3!\3!\5!\u0383\n!\3\"\3\"\3\"\5\"\u0388"+
"\n\"\3#\3#\3#\3#\5#\u038e\n#\3$\3$\3$\3%\3%\3%\7%\u0396\n%\f%\16%\u0399"+
"\13%\3&\3&\3&\3&\3&\5&\u03a0\n&\3\'\3\'\3\'\3\'\3\'\5\'\u03a7\n\'\3(\3"+
"(\3(\3(\5(\u03ad\n(\3(\3(\5(\u03b1\n(\3(\5(\u03b4\n(\3(\3(\3(\3(\3(\5"+
"(\u03bb\n(\3(\3(\3(\5(\u03c0\n(\5(\u03c2\n(\3)\3)\3)\3)\5)\u03c8\n)\3"+
")\3)\3*\3*\5*\u03ce\n*\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\7+\u03db\n+\f"+
"+\16+\u03de\13+\3,\3,\3,\5,\u03e3\n,\3,\5,\u03e6\n,\3,\3,\3,\5,\u03eb"+
"\n,\3,\5,\u03ee\n,\5,\u03f0\n,\3-\3-\5-\u03f4\n-\3-\3-\3-\3-\5-\u03fa"+
"\n-\3-\5-\u03fd\n-\3-\3-\3-\5-\u0402\n-\3.\3.\3.\3.\5.\u0408\n.\3.\3."+
"\3.\3.\3/\3/\3/\7/\u0411\n/\f/\16/\u0414\13/\3\60\3\60\3\60\3\60\5\60"+
"\u041a\n\60\3\60\5\60\u041d\n\60\3\60\5\60\u0420\n\60\3\60\3\60\7\60\u0424"+
"\n\60\f\60\16\60\u0427\13\60\3\61\3\61\3\61\5\61\u042c\n\61\3\61\5\61"+
"\u042f\n\61\3\62\3\62\3\62\7\62\u0434\n\62\f\62\16\62\u0437\13\62\3\63"+
"\3\63\3\63\3\63\3\63\5\63\u043e\n\63\3\63\5\63\u0441\n\63\5\63\u0443\n"+
"\63\3\64\3\64\3\64\7\64\u0448\n\64\f\64\16\64\u044b\13\64\3\65\3\65\3"+
"\65\3\65\5\65\u0451\n\65\3\65\3\65\3\65\3\65\5\65\u0457\n\65\3\66\3\66"+
"\5\66\u045b\n\66\3\66\3\66\3\67\3\67\3\67\5\67\u0462\n\67\3\67\3\67\3"+
"\67\5\67\u0467\n\67\3\67\5\67\u046a\n\67\3\67\7\67\u046d\n\67\f\67\16"+
"\67\u0470\13\67\38\38\38\38\38\38\58\u0478\n8\38\38\58\u047c\n8\39\39"+
"\39\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\5;\u048c\n;\3;\3;\3<\3<\7<\u0492"+
"\n<\f<\16<\u0495\13<\3=\7=\u0498\n=\f=\16=\u049b\13=\3=\3=\5=\u049f\n"+
"=\3=\5=\u04a2\n=\3=\5=\u04a5\n=\3=\3=\5=\u04a9\n=\3=\5=\u04ac\n=\3=\3"+
"=\3=\3=\5=\u04b2\n=\3>\3>\3>\3>\3?\3?\3?\7?\u04bb\n?\f?\16?\u04be\13?"+
"\3@\3@\5@\u04c2\n@\3@\5@\u04c5\n@\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3C\3C"+
"\3C\3C\7C\u04d5\nC\fC\16C\u04d8\13C\3D\3D\5D\u04dc\nD\3E\3E\3E\3E\7E\u04e2"+
"\nE\fE\16E\u04e5\13E\3E\3E\3F\3F\5F\u04eb\nF\3G\3G\5G\u04ef\nG\3H\3H\3"+
"H\7H\u04f4\nH\fH\16H\u04f7\13H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u0504"+
"\nI\5I\u0506\nI\3J\3J\3J\3J\5J\u050c\nJ\3J\3J\3K\3K\3K\3L\3L\3L\3L\3L"+
"\3L\7L\u0519\nL\fL\16L\u051c\13L\5L\u051e\nL\3M\3M\3M\5M\u0523\nM\3M\3"+
"M\3N\3N\3N\3N\5N\u052b\nN\3N\3N\5N\u052f\nN\3N\3N\5N\u0533\nN\3N\5N\u0536"+
"\nN\3N\3N\3N\5N\u053b\nN\3N\3N\3N\5N\u0540\nN\3N\5N\u0543\nN\3N\3N\5N"+
"\u0547\nN\3N\3N\3N\7N\u054c\nN\fN\16N\u054f\13N\3N\3N\3N\7N\u0554\nN\f"+
"N\16N\u0557\13N\3N\3N\3N\3N\3N\5N\u055e\nN\3N\3N\3N\7N\u0563\nN\fN\16"+
"N\u0566\13N\3N\3N\3N\5N\u056b\nN\5N\u056d\nN\3O\3O\3O\5O\u0572\nO\3O\3"+
"O\3P\3P\3P\3P\5P\u057a\nP\3P\3P\3P\5P\u057f\nP\3Q\3Q\5Q\u0583\nQ\3Q\5"+
"Q\u0586\nQ\3R\3R\3R\7R\u058b\nR\fR\16R\u058e\13R\3R\3R\3R\3S\3S\3S\3S"+
"\3T\3T\5T\u0599\nT\3T\3T\3T\3T\3U\3U\3U\3V\3V\3V\7V\u05a5\nV\fV\16V\u05a8"+
"\13V\3W\3W\5W\u05ac\nW\3X\3X\3X\3Y\3Y\3Y\5Y\u05b4\nY\3Y\3Y\3Y\3Y\5Y\u05ba"+
"\nY\3Y\5Y\u05bd\nY\3Z\3Z\3Z\7Z\u05c2\nZ\fZ\16Z\u05c5\13Z\3[\3[\3[\5[\u05ca"+
"\n[\3\\\3\\\7\\\u05ce\n\\\f\\\16\\\u05d1\13\\\3]\3]\7]\u05d5\n]\f]\16"+
"]\u05d8\13]\3^\3^\3^\5^\u05dd\n^\3^\5^\u05e0\n^\3^\5^\u05e3\n^\3^\3^\3"+
"^\5^\u05e8\n^\3_\3_\3_\3_\7_\u05ee\n_\f_\16_\u05f1\13_\3`\3`\3`\3`\3a"+
"\3a\3b\3b\3b\5b\u05fc\nb\3b\5b\u05ff\nb\3b\3b\3c\3c\3c\7c\u0606\nc\fc"+
"\16c\u0609\13c\3d\3d\3d\5d\u060e\nd\3e\3e\5e\u0612\ne\3e\5e\u0615\ne\3"+
"e\5e\u0618\ne\3f\3f\3f\3g\3g\3g\3g\3g\5g\u0622\ng\3h\3h\3h\3h\5h\u0628"+
"\nh\3h\5h\u062b\nh\3h\3h\3h\5h\u0630\nh\3h\5h\u0633\nh\3h\3h\5h\u0637"+
"\nh\3i\3i\3i\3i\5i\u063d\ni\3i\5i\u0640\ni\3j\3j\7j\u0644\nj\fj\16j\u0647"+
"\13j\3j\3j\3j\3j\3k\3k\3k\3k\3k\3k\5k\u0653\nk\3k\3k\3k\5k\u0658\nk\5"+
"k\u065a\nk\3k\3k\3l\3l\3l\3l\3l\5l\u0663\nl\3l\5l\u0666\nl\3l\5l\u0669"+
"\nl\3m\3m\3m\3m\7m\u066f\nm\fm\16m\u0672\13m\3m\3m\3m\3m\7m\u0678\nm\f"+
"m\16m\u067b\13m\5m\u067d\nm\3n\3n\3n\3n\3o\3o\5o\u0685\no\3o\3o\3p\3p"+
"\5p\u068b\np\3p\3p\5p\u068f\np\3p\5p\u0692\np\3q\3q\3q\7q\u0697\nq\fq"+
"\16q\u069a\13q\3r\3r\3r\5r\u069f\nr\3s\3s\3s\3s\3s\7s\u06a6\ns\fs\16s"+
"\u06a9\13s\3s\3s\3t\3t\3t\3t\3t\3t\7t\u06b3\nt\ft\16t\u06b6\13t\3t\3t"+
"\3u\3u\5u\u06bc\nu\3v\3v\3v\3v\3v\7v\u06c3\nv\fv\16v\u06c6\13v\5v\u06c8"+
"\nv\3v\5v\u06cb\nv\3w\3w\3w\7w\u06d0\nw\fw\16w\u06d3\13w\3x\3x\3x\5x\u06d8"+
"\nx\3y\3y\3z\5z\u06dd\nz\3z\3z\3z\3z\5z\u06e3\nz\3z\3z\3z\3z\5z\u06e9"+
"\nz\3z\5z\u06ec\nz\3z\3z\3z\3z\3z\3z\5z\u06f4\nz\3z\3z\3z\3z\5z\u06fa"+
"\nz\3z\3z\5z\u06fe\nz\3z\5z\u0701\nz\3z\5z\u0704\nz\3{\3{\3{\3{\3{\5{"+
"\u070b\n{\3{\3{\5{\u070f\n{\3|\3|\3|\3|\3|\5|\u0716\n|\3}\3}\5}\u071a"+
"\n}\3}\3}\5}\u071e\n}\3}\3}\5}\u0722\n}\5}\u0724\n}\3~\3~\3~\3~\3\177"+
"\3\177\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081"+
"\5\u0081\u0735\n\u0081\3\u0081\3\u0081\5\u0081\u0739\n\u0081\3\u0081\5"+
"\u0081\u073c\n\u0081\3\u0081\3\u0081\5\u0081\u0740\n\u0081\3\u0081\5\u0081"+
"\u0743\n\u0081\3\u0081\3\u0081\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082"+
"\7\u0082\u074c\n\u0082\f\u0082\16\u0082\u074f\13\u0082\3\u0083\3\u0083"+
"\3\u0083\3\u0083\7\u0083\u0755\n\u0083\f\u0083\16\u0083\u0758\13\u0083"+
"\3\u0084\3\u0084\3\u0084\5\u0084\u075d\n\u0084\5\u0084\u075f\n\u0084\3"+
"\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087"+
"\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088"+
"\3\u0088\5\u0088\u0774\n\u0088\3\u0089\3\u0089\3\u0089\7\u0089\u0779\n"+
"\u0089\f\u0089\16\u0089\u077c\13\u0089\3\u008a\6\u008a\u077f\n\u008a\r"+
"\u008a\16\u008a\u0780\3\u008b\3\u008b\3\u008b\5\u008b\u0786\n\u008b\3"+
"\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u078e\n\u008c\3"+
"\u008c\5\u008c\u0791\n\u008c\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\7"+
"\u008d\u0798\n\u008d\f\u008d\16\u008d\u079b\13\u008d\3\u008d\3\u008d\3"+
"\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u07a3\n\u008e\3\u008e\5\u008e\u07a6"+
"\n\u008e\5\u008e\u07a8\n\u008e\3\u008e\5\u008e\u07ab\n\u008e\3\u008f\3"+
"\u008f\5\u008f\u07af\n\u008f\3\u008f\5\u008f\u07b2\n\u008f\3\u008f\5\u008f"+
"\u07b5\n\u008f\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\7\u0090"+
"\u07bd\n\u0090\f\u0090\16\u0090\u07c0\13\u0090\3\u0091\3\u0091\3\u0091"+
"\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\6\u0093\u07cb\n\u0093"+
"\r\u0093\16\u0093\u07cc\3\u0093\5\u0093\u07d0\n\u0093\3\u0093\3\u0093"+
"\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\6\u0093\u07d9\n\u0093\r\u0093"+
"\16\u0093\u07da\3\u0093\5\u0093\u07de\n\u0093\3\u0093\3\u0093\3\u0093"+
"\3\u0093\5\u0093\u07e4\n\u0093\3\u0094\3\u0094\3\u0094\7\u0094\u07e9\n"+
"\u0094\f\u0094\16\u0094\u07ec\13\u0094\3\u0095\3\u0095\3\u0095\7\u0095"+
"\u07f1\n\u0095\f\u0095\16\u0095\u07f4\13\u0095\3\u0096\3\u0096\3\u0096"+
"\7\u0096\u07f9\n\u0096\f\u0096\16\u0096\u07fc\13\u0096\3\u0097\3\u0097"+
"\3\u0097\5\u0097\u0801\n\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098"+
"\3\u0098\3\u0098\5\u0098\u080a\n\u0098\3\u0098\3\u0098\3\u0098\3\u0098"+
"\5\u0098\u0810\n\u0098\3\u0098\3\u0098\5\u0098\u0814\n\u0098\3\u0098\3"+
"\u0098\5\u0098\u0818\n\u0098\5\u0098\u081a\n\u0098\7\u0098\u081c\n\u0098"+
"\f\u0098\16\u0098\u081f\13\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+
"\5\u0099\u0826\n\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u082c\n"+
"\u0099\3\u0099\3\u0099\5\u0099\u0830\n\u0099\3\u0099\3\u0099\5\u0099\u0834"+
"\n\u0099\5\u0099\u0836\n\u0099\7\u0099\u0838\n\u0099\f\u0099\16\u0099"+
"\u083b\13\u0099\3\u0099\5\u0099\u083e\n\u0099\3\u0099\3\u0099\3\u0099"+
"\5\u0099\u0843\n\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\7\u0099"+
"\u084a\n\u0099\f\u0099\16\u0099\u084d\13\u0099\5\u0099\u084f\n\u0099\3"+
"\u0099\3\u0099\5\u0099\u0853\n\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3"+
"\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u085d\n\u0099\3\u0099\3\u0099\5"+
"\u0099\u0861\n\u0099\5\u0099\u0863\n\u0099\3\u009a\3\u009a\3\u009b\3\u009b"+
"\3\u009b\3\u009b\3\u009b\7\u009b\u086c\n\u009b\f\u009b\16\u009b\u086f"+
"\13\u009b\5\u009b\u0871\n\u009b\3\u009c\3\u009c\3\u009c\7\u009c\u0876"+
"\n\u009c\f\u009c\16\u009c\u0879\13\u009c\3\u009d\3\u009d\3\u009d\7\u009d"+
"\u087e\n\u009d\f\u009d\16\u009d\u0881\13\u009d\3\u009e\3\u009e\3\u009e"+
"\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\5\u009e\u088b\n\u009e\3\u009e"+
"\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+
"\7\u009e\u0897\n\u009e\f\u009e\16\u009e\u089a\13\u009e\3\u009e\3\u009e"+
"\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\7\u009e\u08a4\n\u009e"+
"\f\u009e\16\u009e\u08a7\13\u009e\5\u009e\u08a9\n\u009e\3\u009e\3\u009e"+
"\5\u009e\u08ad\n\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\7\u009e"+
"\u08b4\n\u009e\f\u009e\16\u009e\u08b7\13\u009e\3\u009e\3\u009e\5\u009e"+
"\u08bb\n\u009e\3\u009e\5\u009e\u08be\n\u009e\3\u009f\3\u009f\5\u009f\u08c2"+
"\n\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\7\u00a0\u08c8\n\u00a0\f\u00a0"+
"\16\u00a0\u08cb\13\u00a0\3\u00a1\3\u00a1\3\u00a1\5\u00a1\u08d0\n\u00a1"+
"\3\u00a2\3\u00a2\5\u00a2\u08d4\n\u00a2\3\u00a3\3\u00a3\3\u00a4\3\u00a4"+
"\3\u00a4\3\u00a5\3\u00a5\3\u00a5\5\u00a5\u08de\n\u00a5\3\u00a5\3\u00a5"+
"\3\u00a5\3\u00a5\3\u00a5\5\u00a5\u08e5\n\u00a5\3\u00a5\3\u00a5\3\u00a5"+
"\5\u00a5\u08ea\n\u00a5\3\u00a5\3\u00a5\5\u00a5\u08ee\n\u00a5\3\u00a5\3"+
"\u00a5\3\u00a6\3\u00a6\5\u00a6\u08f4\n\u00a6\3\u00a6\3\u00a6\3\u00a6\5"+
"\u00a6\u08f9\n\u00a6\3\u00a6\3\u00a6\5\u00a6\u08fd\n\u00a6\3\u00a7\3\u00a7"+
"\3\u00a7\3\u00a7\7\u00a7\u0903\n\u00a7\f\u00a7\16\u00a7\u0906\13\u00a7"+
"\5\u00a7\u0908\n\u00a7\3\u00a7\3\u00a7\5\u00a7\u090c\n\u00a7\3\u00a8\3"+
"\u00a8\3\u00a8\5\u00a8\u0911\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\5\u00a8\u0919\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\3\u00a8\5\u00a8\u0922\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\3\u00a8\5\u00a8\u092a\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\3\u00a8\5\u00a8\u0932\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\3\u00a8\5\u00a8\u093a\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\7\u00a8"+
"\u0947\n\u00a8\f\u00a8\16\u00a8\u094a\13\u00a8\3\u00a8\3\u00a8\3\u00a8"+
"\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0953\n\u00a8\3\u00a8\3\u00a8"+
"\5\u00a8\u0957\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8"+
"\u095e\n\u00a8\3\u00a8\3\u00a8\5\u00a8\u0962\n\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8"+
"\u096e\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8"+
"\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8"+
"\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\7\u00a8"+
"\u0988\n\u00a8\f\u00a8\16\u00a8\u098b\13\u00a8\3\u00a8\3\u00a8\3\u00a8"+
"\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8"+
"\3\u00a8\3\u00a8\5\u00a8\u099b\n\u00a8\3\u00a8\3\u00a8\5\u00a8\u099f\n"+
"\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8"+
"\5\u00a8\u09a9\n\u00a8\3\u00a8\5\u00a8\u09ac\n\u00a8\3\u00a8\3\u00a8\3"+
"\u00a8\5\u00a8\u09b1\n\u00a8\3\u00a9\3\u00a9\3\u00a9\5\u00a9\u09b6\n\u00a9"+
"\3\u00a9\3\u00a9\5\u00a9\u09ba\n\u00a9\3\u00a9\3\u00a9\5\u00a9\u09be\n"+
"\u00a9\3\u00aa\3\u00aa\5\u00aa\u09c2\n\u00aa\3\u00ab\3\u00ab\3\u00ab\7"+
"\u00ab\u09c7\n\u00ab\f\u00ab\16\u00ab\u09ca\13\u00ab\3\u00ac\3\u00ac\3"+
"\u00ac\3\u00ac\3\u00ac\5\u00ac\u09d1\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u09d5"+
"\n\u00ac\3\u00ac\5\u00ac\u09d8\n\u00ac\3\u00ad\3\u00ad\3\u00ad\5\u00ad"+
"\u09dd\n\u00ad\3\u00ad\5\u00ad\u09e0\n\u00ad\3\u00ae\3\u00ae\3\u00ae\5"+
"\u00ae\u09e5\n\u00ae\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u09eb\n\u00af"+
"\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0"+
"\3\u00b0\5\u00b0\u09f7\n\u00b0\3\u00b1\5\u00b1\u09fa\n\u00b1\3\u00b1\3"+
"\u00b1\3\u00b1\7\u00b1\u09ff\n\u00b1\f\u00b1\16\u00b1\u0a02\13\u00b1\3"+
"\u00b2\5\u00b2\u0a05\n\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3"+
"\u00b3\3\u00b4\3\u00b4\3\u00b5\3\u00b5\7\u00b5\u0a11\n\u00b5\f\u00b5\16"+
"\u00b5\u0a14\13\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\5\u00b6"+
"\u0a1b\n\u00b6\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\7\u00b7\u0a22\n"+
"\u00b7\f\u00b7\16\u00b7\u0a25\13\u00b7\3\u00b8\3\u00b8\3\u00b8\7\u00b8"+
"\u0a2a\n\u00b8\f\u00b8\16\u00b8\u0a2d\13\u00b8\3\u00b9\5\u00b9\u0a30\n"+
"\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u0a35\n\u00b9\3\u00ba\3\u00ba\3"+
"\u00ba\3\u00ba\5\u00ba\u0a3b\n\u00ba\3\u00ba\5\u00ba\u0a3e\n\u00ba\5\u00ba"+
"\u0a40\n\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+
"\5\u00bb\u0a49\n\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb\u0a4f\n"+
"\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc\7\u00bc\u0a55\n\u00bc\f\u00bc\16"+
"\u00bc\u0a58\13\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00be\3\u00be"+
"\5\u00be\u0a60\n\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u0a66\n"+
"\u00bf\3\u00bf\3\u00bf\5\u00bf\u0a6a\n\u00bf\3\u00bf\3\u00bf\3\u00c0\3"+
"\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u0a73\n\u00c0\3\u00c0\3\u00c0\3"+
"\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\5\u00c2"+
"\u0a7f\n\u00c2\5\u00c2\u0a81\n\u00c2\3\u00c2\3\u00c2\5\u00c2\u0a85\n\u00c2"+
"\3\u00c2\3\u00c2\3\u00c3\3\u00c3\5\u00c3\u0a8b\n\u00c3\3\u00c3\3\u00c3"+
"\3\u00c3\5\u00c3\u0a90\n\u00c3\3\u00c3\5\u00c3\u0a93\n\u00c3\3\u00c3\5"+
"\u00c3\u0a96\n\u00c3\3\u00c4\3\u00c4\7\u00c4\u0a9a\n\u00c4\f\u00c4\16"+
"\u00c4\u0a9d\13\u00c4\3\u00c5\3\u00c5\5\u00c5\u0aa1\n\u00c5\3\u00c5\3"+
"\u00c5\5\u00c5\u0aa5\n\u00c5\3\u00c5\3\u00c5\5\u00c5\u0aa9\n\u00c5\3\u00c5"+
"\3\u00c5\5\u00c5\u0aad\n\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6"+
"\3\u00c6\3\u00c7\3\u00c7\3\u00c7\7\u00c7\u0ab8\n\u00c7\f\u00c7\16\u00c7"+
"\u0abb\13\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0ac2"+
"\n\u00c8\5\u00c8\u0ac4\n\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9"+
"\5\u00c9\u0acb\n\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+
"\3\u00cb\3\u00cb\5\u00cb\u0ad5\n\u00cb\3\u00cb\3\u00cb\3\u00cb\5\u00cb"+
"\u0ada\n\u00cb\3\u00cb\5\u00cb\u0add\n\u00cb\3\u00cb\5\u00cb\u0ae0\n\u00cb"+
"\3\u00cb\5\u00cb\u0ae3\n\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc"+
"\3\u00cc\5\u00cc\u0aeb\n\u00cc\3\u00cd\3\u00cd\3\u00cd\7\u00cd\u0af0\n"+
"\u00cd\f\u00cd\16\u00cd\u0af3\13\u00cd\3\u00ce\5\u00ce\u0af6\n\u00ce\3"+
"\u00ce\3\u00ce\3\u00ce\7\u00ce\u0afb\n\u00ce\f\u00ce\16\u00ce\u0afe\13"+
"\u00ce\3\u00cf\3\u00cf\3\u00cf\7\u00cf\u0b03\n\u00cf\f\u00cf\16\u00cf"+
"\u0b06\13\u00cf\3\u00d0\3\u00d0\3\u00d0\7\u00d0\u0b0b\n\u00d0\f\u00d0"+
"\16\u00d0\u0b0e\13\u00d0\3\u00d1\3\u00d1\5\u00d1\u0b12\n\u00d1\3\u00d2"+
"\3\u00d2\5\u00d2\u0b16\n\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3"+
"\5\u00d3\u0b1d\n\u00d3\3\u00d3\5\u00d3\u0b20\n\u00d3\3\u00d4\3\u00d4\3"+
"\u00d4\3\u00d4\3\u00d4\5\u00d4\u0b27\n\u00d4\3\u00d4\5\u00d4\u0b2a\n\u00d4"+
"\3\u00d5\3\u00d5\3\u00d5\7\u00d5\u0b2f\n\u00d5\f\u00d5\16\u00d5\u0b32"+
"\13\u00d5\3\u00d6\3\u00d6\3\u00d6\7\u00d6\u0b37\n\u00d6\f\u00d6\16\u00d6"+
"\u0b3a\13\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7"+
"\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0b46\n\u00d7\3\u00d8\3\u00d8\5\u00d8"+
"\u0b4a\n\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\5\u00d9"+
"\u0b52\n\u00d9\3\u00da\3\u00da\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc"+
"\3\u00dc\3\u00dc\5\u00dc\u0b5d\n\u00dc\3\u00dd\3\u00dd\3\u00dd\5\u00dd"+
"\u0b62\n\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\5\u00dd\u0b68\n\u00dd\3"+
"\u00de\3\u00de\3\u00de\5\u00de\u0b6d\n\u00de\3\u00de\3\u00de\3\u00df\3"+
"\u00df\3\u00df\5\u00df\u0b74\n\u00df\3\u00df\3\u00df\3\u00e0\3\u00e0\3"+
"\u00e0\3\u00e0\7\u00e0\u0b7c\n\u00e0\f\u00e0\16\u00e0\u0b7f\13\u00e0\3"+
"\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\5\u00e1\u0b86\n\u00e1\3\u00e2\3"+
"\u00e2\3\u00e2\7\u00e2\u0b8b\n\u00e2\f\u00e2\16\u00e2\u0b8e\13\u00e2\3"+
"\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\5\u00e3\u0b95\n\u00e3\3\u00e3\3"+
"\u00e3\3\u00e3\5\u00e3\u0b9a\n\u00e3\3\u00e3\3\u00e3\5\u00e3\u0b9e\n\u00e3"+
"\3\u00e3\5\u00e3\u0ba1\n\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\5\u00e4"+
"\u0ba7\n\u00e4\7\u00e4\u0ba9\n\u00e4\f\u00e4\16\u00e4\u0bac\13\u00e4\3"+
"\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5"+
"\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5"+
"\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5"+
"\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5"+
"\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5"+
"\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u0be2"+
"\n\u00e5\3\u00e6\3\u00e6\3\u00e6\5\u00e6\u0be7\n\u00e6\3\u00e7\3\u00e7"+
"\5\u00e7\u0beb\n\u00e7\3\u00e8\3\u00e8\5\u00e8\u0bef\n\u00e8\3\u00e8\5"+
"\u00e8\u0bf2\n\u00e8\3\u00e8\5\u00e8\u0bf5\n\u00e8\3\u00e8\5\u00e8\u0bf8"+
"\n\u00e8\3\u00e8\5\u00e8\u0bfb\n\u00e8\3\u00e8\5\u00e8\u0bfe\n\u00e8\3"+
"\u00e8\5\u00e8\u0c01\n\u00e8\3\u00e8\5\u00e8\u0c04\n\u00e8\3\u00e8\3\u00e8"+
"\5\u00e8\u0c08\n\u00e8\3\u00e8\5\u00e8\u0c0b\n\u00e8\3\u00e8\5\u00e8\u0c0e"+
"\n\u00e8\3\u00e8\5\u00e8\u0c11\n\u00e8\3\u00e8\5\u00e8\u0c14\n\u00e8\3"+
"\u00e8\5\u00e8\u0c17\n\u00e8\3\u00e8\5\u00e8\u0c1a\n\u00e8\3\u00e8\3\u00e8"+
"\5\u00e8\u0c1e\n\u00e8\3\u00e8\5\u00e8\u0c21\n\u00e8\3\u00e8\5\u00e8\u0c24"+
"\n\u00e8\3\u00e8\5\u00e8\u0c27\n\u00e8\3\u00e8\5\u00e8\u0c2a\n\u00e8\3"+
"\u00e8\5\u00e8\u0c2d\n\u00e8\3\u00e8\3\u00e8\5\u00e8\u0c31\n\u00e8\3\u00e8"+
"\5\u00e8\u0c34\n\u00e8\3\u00e8\5\u00e8\u0c37\n\u00e8\3\u00e8\5\u00e8\u0c3a"+
"\n\u00e8\3\u00e8\5\u00e8\u0c3d\n\u00e8\3\u00e8\3\u00e8\5\u00e8\u0c41\n"+
"\u00e8\3\u00e8\5\u00e8\u0c44\n\u00e8\3\u00e8\5\u00e8\u0c47\n\u00e8\3\u00e8"+
"\5\u00e8\u0c4a\n\u00e8\3\u00e8\3\u00e8\5\u00e8\u0c4e\n\u00e8\3\u00e8\5"+
"\u00e8\u0c51\n\u00e8\3\u00e8\5\u00e8\u0c54\n\u00e8\3\u00e8\3\u00e8\5\u00e8"+
"\u0c58\n\u00e8\3\u00e8\5\u00e8\u0c5b\n\u00e8\3\u00e8\3\u00e8\5\u00e8\u0c5f"+
"\n\u00e8\3\u00e8\5\u00e8\u0c62\n\u00e8\3\u00e9\3\u00e9\3\u00e9\5\u00e9"+
"\u0c67\n\u00e9\3\u00e9\3\u00e9\3\u00ea\3\u00ea\3\u00ea\5\u00ea\u0c6e\n"+
"\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb\5\u00eb\u0c75\n\u00eb\3"+
"\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\5\u00ec\u0c7c\n\u00ec\3\u00ec\3"+
"\u00ec\3\u00ed\3\u00ed\3\u00ed\5\u00ed\u0c83\n\u00ed\3\u00ed\3\u00ed\3"+
"\u00ee\3\u00ee\3\u00ee\5\u00ee\u0c8a\n\u00ee\3\u00ee\3\u00ee\3\u00ef\3"+
"\u00ef\3\u00ef\5\u00ef\u0c91\n\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3"+
"\u00f0\5\u00f0\u0c98\n\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1\5"+
"\u00f1\u0c9f\n\u00f1\3\u00f1\3\u00f1\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3"+
"\u00f3\5\u00f3\u0ca8\n\u00f3\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\5"+
"\u00f4\u0caf\n\u00f4\3\u00f5\3\u00f5\5\u00f5\u0cb3\n\u00f5\3\u00f5\3\u00f5"+
"\3\u00f6\3\u00f6\5\u00f6\u0cb9\n\u00f6\3\u00f7\3\u00f7\3\u00f7\5\u00f7"+
"\u0cbe\n\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\5\u00f9"+
"\u0cc6\n\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa\7\u00fa\u0ccd\n"+
"\u00fa\f\u00fa\16\u00fa\u0cd0\13\u00fa\3\u00fa\5\u00fa\u0cd3\n\u00fa\3"+
"\u00fb\3\u00fb\3\u00fb\7\u00fb\u0cd8\n\u00fb\f\u00fb\16\u00fb\u0cdb\13"+
"\u00fb\3\u00fb\5\u00fb\u0cde\n\u00fb\3\u00fc\3\u00fc\5\u00fc\u0ce2\n\u00fc"+
"\3\u00fc\3\u00fc\3\u00fc\3\u00fc\2\2\u00fd\2\4\6\b\n\f\16\20\22\24\26"+
"\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|"+
"~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096"+
"\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae"+
"\u00b0\u00b2\u00b4\u00b6\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\2\25\3\2\u008d\u008e"+
"\4\2\u008f\u008f\u0098\u0098\4\2\13\13\u0099\u0099\3\2\u0086\u0087\5\2"+
"\u00ae\u00ae\u00b0\u00b0\u00b3\u00b3\4\2\u00a0\u00a0\u00a3\u00a3\5\2\u009e"+
"\u009e\u00a6\u00a6\u00a8\u00a8\3\2,-\4\2\20\20\u0099\u0099\3\2XY\3\2Z"+
"[\3\2\\]\3\2^_\3\2`a\4\2\24\24bc\3\2df\3\2gi\3\2jl\3\2\u00c6\u00c7\u0e95"+
"\2\u01fc\3\2\2\2\4\u0206\3\2\2\2\6\u020c\3\2\2\2\b\u020f\3\2\2\2\n\u0212"+
"\3\2\2\2\f\u022e\3\2\2\2\16\u023c\3\2\2\2\20\u0243\3\2\2\2\22\u0247\3"+
"\2\2\2\24\u024d\3\2\2\2\26\u0257\3\2\2\2\30\u025f\3\2\2\2\32\u0268\3\2"+
"\2\2\34\u026a\3\2\2\2\36\u027b\3\2\2\2 \u0290\3\2\2\2\"\u0295\3\2\2\2"+
"$\u02be\3\2\2\2&\u02d3\3\2\2\2(\u02da\3\2\2\2*\u02de\3\2\2\2,\u02ea\3"+
"\2\2\2.\u02ff\3\2\2\2\60\u0301\3\2\2\2\62\u030c\3\2\2\2\64\u031d\3\2\2"+
"\2\66\u0329\3\2\2\28\u032c\3\2\2\2:\u033f\3\2\2\2<\u0365\3\2\2\2>\u0372"+
"\3\2\2\2@\u037d\3\2\2\2B\u0384\3\2\2\2D\u0389\3\2\2\2F\u038f\3\2\2\2H"+
"\u0392\3\2\2\2J\u039f\3\2\2\2L\u03a1\3\2\2\2N\u03a8\3\2\2\2P\u03c7\3\2"+
"\2\2R\u03cb\3\2\2\2T\u03d7\3\2\2\2V\u03e5\3\2\2\2X\u03f1\3\2\2\2Z\u0403"+
"\3\2\2\2\\\u040d\3\2\2\2^\u0415\3\2\2\2`\u0428\3\2\2\2b\u0430\3\2\2\2"+
"d\u0438\3\2\2\2f\u0444\3\2\2\2h\u0456\3\2\2\2j\u0458\3\2\2\2l\u045e\3"+
"\2\2\2n\u0471\3\2\2\2p\u047d\3\2\2\2r\u0480\3\2\2\2t\u0487\3\2\2\2v\u048f"+
"\3\2\2\2x\u04b1\3\2\2\2z\u04b3\3\2\2\2|\u04b7\3\2\2\2~\u04c1\3\2\2\2\u0080"+
"\u04c6\3\2\2\2\u0082\u04cd\3\2\2\2\u0084\u04d0\3\2\2\2\u0086\u04d9\3\2"+
"\2\2\u0088\u04dd\3\2\2\2\u008a\u04ea\3\2\2\2\u008c\u04ec\3\2\2\2\u008e"+
"\u04f0\3\2\2\2\u0090\u0505\3\2\2\2\u0092\u0507\3\2\2\2\u0094\u050f\3\2"+
"\2\2\u0096\u051d\3\2\2\2\u0098\u051f\3\2\2\2\u009a\u056c\3\2\2\2\u009c"+
"\u056e\3\2\2\2\u009e\u057e\3\2\2\2\u00a0\u0580\3\2\2\2\u00a2\u0587\3\2"+
"\2\2\u00a4\u0592\3\2\2\2\u00a6\u0596\3\2\2\2\u00a8\u059e\3\2\2\2\u00aa"+
"\u05a1\3\2\2\2\u00ac\u05ab\3\2\2\2\u00ae\u05ad\3\2\2\2\u00b0\u05b3\3\2"+
"\2\2\u00b2\u05be\3\2\2\2\u00b4\u05c6\3\2\2\2\u00b6\u05cf\3\2\2\2\u00b8"+
"\u05d2\3\2\2\2\u00ba\u05e2\3\2\2\2\u00bc\u05e9\3\2\2\2\u00be\u05f2\3\2"+
"\2\2\u00c0\u05f6\3\2\2\2\u00c2\u05fb\3\2\2\2\u00c4\u0602\3\2\2\2\u00c6"+
"\u060d\3\2\2\2\u00c8\u060f\3\2\2\2\u00ca\u0619\3\2\2\2\u00cc\u061c\3\2"+
"\2\2\u00ce\u0627\3\2\2\2\u00d0\u0638\3\2\2\2\u00d2\u0641\3\2\2\2\u00d4"+
"\u064c\3\2\2\2\u00d6\u065d\3\2\2\2\u00d8\u067c\3\2\2\2\u00da\u067e\3\2"+
"\2\2\u00dc\u0684\3\2\2\2\u00de\u068a\3\2\2\2\u00e0\u0693\3\2\2\2\u00e2"+
"\u069e\3\2\2\2\u00e4\u06a0\3\2\2\2\u00e6\u06ac\3\2\2\2\u00e8\u06bb\3\2"+
"\2\2\u00ea\u06ca\3\2\2\2\u00ec\u06cc\3\2\2\2\u00ee\u06d4\3\2\2\2\u00f0"+
"\u06d9\3\2\2\2\u00f2\u06dc\3\2\2\2\u00f4\u0705\3\2\2\2\u00f6\u0710\3\2"+
"\2\2\u00f8\u0719\3\2\2\2\u00fa\u0725\3\2\2\2\u00fc\u0729\3\2\2\2\u00fe"+
"\u072e\3\2\2\2\u0100\u0731\3\2\2\2\u0102\u0746\3\2\2\2\u0104\u0750\3\2"+
"\2\2\u0106\u0759\3\2\2\2\u0108\u0760\3\2\2\2\u010a\u0763\3\2\2\2\u010c"+
"\u0768\3\2\2\2\u010e\u076f\3\2\2\2\u0110\u0775\3\2\2\2\u0112\u077e\3\2"+
"\2\2\u0114\u0785\3\2\2\2\u0116\u0787\3\2\2\2\u0118\u0792\3\2\2\2\u011a"+
"\u079e\3\2\2\2\u011c\u07ac\3\2\2\2\u011e\u07b8\3\2\2\2\u0120\u07c1\3\2"+
"\2\2\u0122\u07c5\3\2\2\2\u0124\u07e3\3\2\2\2\u0126\u07e5\3\2\2\2\u0128"+
"\u07ed\3\2\2\2\u012a\u07f5\3\2\2\2\u012c\u0800\3\2\2\2\u012e\u0802\3\2"+
"\2\2\u0130\u0820\3\2\2\2\u0132\u0864\3\2\2\2\u0134\u0866\3\2\2\2\u0136"+
"\u0872\3\2\2\2\u0138\u087a\3\2\2\2\u013a\u08bd\3\2\2\2\u013c\u08bf\3\2"+
"\2\2\u013e\u08c3\3\2\2\2\u0140\u08cc\3\2\2\2\u0142\u08d1\3\2\2\2\u0144"+
"\u08d5\3\2\2\2\u0146\u08d7\3\2\2\2\u0148\u08da\3\2\2\2\u014a\u08f1\3\2"+
"\2\2\u014c\u08fe\3\2\2\2\u014e\u09b0\3\2\2\2\u0150\u09b5\3\2\2\2\u0152"+
"\u09c1\3\2\2\2\u0154\u09c3\3\2\2\2\u0156\u09d0\3\2\2\2\u0158\u09d9\3\2"+
"\2\2\u015a\u09e4\3\2\2\2\u015c\u09ea\3\2\2\2\u015e\u09f6\3\2\2\2\u0160"+
"\u09f9\3\2\2\2\u0162\u0a04\3\2\2\2\u0164\u0a08\3\2\2\2\u0166\u0a0c\3\2"+
"\2\2\u0168\u0a0e\3\2\2\2\u016a\u0a1a\3\2\2\2\u016c\u0a1e\3\2\2\2\u016e"+
"\u0a26\3\2\2\2\u0170\u0a2f\3\2\2\2\u0172\u0a3f\3\2\2\2\u0174\u0a48\3\2"+
"\2\2\u0176\u0a50\3\2\2\2\u0178\u0a5b\3\2\2\2\u017a\u0a5f\3\2\2\2\u017c"+
"\u0a61\3\2\2\2\u017e\u0a6d\3\2\2\2\u0180\u0a76\3\2\2\2\u0182\u0a7a\3\2"+
"\2\2\u0184\u0a8a\3\2\2\2\u0186\u0a97\3\2\2\2\u0188\u0a9e\3\2\2\2\u018a"+
"\u0ab0\3\2\2\2\u018c\u0ab4\3\2\2\2\u018e\u0ac3\3\2\2\2\u0190\u0ac5\3\2"+
"\2\2\u0192\u0acc\3\2\2\2\u0194\u0ad4\3\2\2\2\u0196\u0ae4\3\2\2\2\u0198"+
"\u0aec\3\2\2\2\u019a\u0af5\3\2\2\2\u019c\u0aff\3\2\2\2\u019e\u0b07\3\2"+
"\2\2\u01a0\u0b11\3\2\2\2\u01a2\u0b15\3\2\2\2\u01a4\u0b17\3\2\2\2\u01a6"+
"\u0b21\3\2\2\2\u01a8\u0b2b\3\2\2\2\u01aa\u0b33\3\2\2\2\u01ac\u0b45\3\2"+
"\2\2\u01ae\u0b49\3\2\2\2\u01b0\u0b4b\3\2\2\2\u01b2\u0b53\3\2\2\2\u01b4"+
"\u0b55\3\2\2\2\u01b6\u0b57\3\2\2\2\u01b8\u0b61\3\2\2\2\u01ba\u0b6c\3\2"+
"\2\2\u01bc\u0b73\3\2\2\2\u01be\u0b77\3\2\2\2\u01c0\u0b85\3\2\2\2\u01c2"+
"\u0b87\3\2\2\2\u01c4\u0b8f\3\2\2\2\u01c6\u0ba2\3\2\2\2\u01c8\u0be1\3\2"+
"\2\2\u01ca\u0be6\3\2\2\2\u01cc\u0bea\3\2\2\2\u01ce\u0c61\3\2\2\2\u01d0"+
"\u0c66\3\2\2\2\u01d2\u0c6d\3\2\2\2\u01d4\u0c74\3\2\2\2\u01d6\u0c7b\3\2"+
"\2\2\u01d8\u0c82\3\2\2\2\u01da\u0c89\3\2\2\2\u01dc\u0c90\3\2\2\2\u01de"+
"\u0c97\3\2\2\2\u01e0\u0c9e\3\2\2\2\u01e2\u0ca2\3\2\2\2\u01e4\u0ca4\3\2"+
"\2\2\u01e6\u0cae\3\2\2\2\u01e8\u0cb2\3\2\2\2\u01ea\u0cb8\3\2\2\2\u01ec"+
"\u0cbd\3\2\2\2\u01ee\u0cbf\3\2\2\2\u01f0\u0cc3\3\2\2\2\u01f2\u0cc9\3\2"+
"\2\2\u01f4\u0cd4\3\2\2\2\u01f6\u0ce1\3\2\2\2\u01f8\u01fb\5\24\13\2\u01f9"+
"\u01fb\5\n\6\2\u01fa\u01f8\3\2\2\2\u01fa\u01f9\3\2\2\2\u01fb\u01fe\3\2"+
"\2\2\u01fc\u01fa\3\2\2\2\u01fc\u01fd\3\2\2\2\u01fd\u01ff\3\2\2\2\u01fe"+
"\u01fc\3\2\2\2\u01ff\u0200\5\u0166\u00b4\2\u0200\u0201\7\2\2\3\u0201\3"+
"\3\2\2\2\u0202\u0205\5\24\13\2\u0203\u0205\5\n\6\2\u0204\u0202\3\2\2\2"+
"\u0204\u0203\3\2\2\2\u0205\u0208\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207"+
"\3\2\2\2\u0207\u0209\3\2\2\2\u0208\u0206\3\2\2\2\u0209\u020a\5\36\20\2"+
"\u020a\u020b\7\2\2\3\u020b\5\3\2\2\2\u020c\u020d\5\u01c2\u00e2\2\u020d"+
"\u020e\7\2\2\3\u020e\7\3\2\2\2\u020f\u0210\5\u01ec\u00f7\2\u0210\u0211"+
"\7\2\2\3\u0211\t\3\2\2\2\u0212\u0214\7\177\2\2\u0213\u0215\5\u0198\u00cd"+
"\2\u0214\u0213\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0217"+
"\7\u0094\2\2\u0217\u0219\7\u0095\2\2\u0218\u0216\3\2\2\2\u0218\u0219\3"+
"\2\2\2\u0219\u021b\3\2\2\2\u021a\u021c\5\u0192\u00ca\2\u021b\u021a\3\2"+
"\2\2\u021b\u021c\3\2\2\2\u021c\u021e\3\2\2\2\u021d\u021f\5\f\7\2\u021e"+
"\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0226\7\u00c5"+
"\2\2\u0221\u0223\7\u0092\2\2\u0222\u0224\5\u00b2Z\2\u0223\u0222\3\2\2"+
"\2\u0223\u0224\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0227\7\u0093\2\2\u0226"+
"\u0221\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u022a\3\2\2\2\u0228\u0229\7\u00c5"+
"\2\2\u0229\u022b\7z\2\2\u022a\u0228\3\2\2\2\u022a\u022b\3\2\2\2\u022b"+
"\u022c\3\2\2\2\u022c\u022d\5\16\b\2\u022d\13\3\2\2\2\u022e\u022f\7\u00c5"+
"\2\2\u022f\u0230\7\u0098\2\2\u0230\r\3\2\2\2\u0231\u0233\7\u0096\2\2\u0232"+
"\u0234\5\20\t\2\u0233\u0232\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0235\3"+
"\2\2\2\u0235\u0236\5\u0122\u0092\2\u0236\u0237\7\u0097\2\2\u0237\u023d"+
"\3\2\2\2\u0238\u0239\7\u0094\2\2\u0239\u023a\5\u01ea\u00f6\2\u023a\u023b"+
"\7\u0095\2\2\u023b\u023d\3\2\2\2\u023c\u0231\3\2\2\2\u023c\u0238\3\2\2"+
"\2\u023d\17\3\2\2\2\u023e\u0244\7\u00c5\2\2\u023f\u0240\7\u0092\2\2\u0240"+
"\u0241\5\u00b2Z\2\u0241\u0242\7\u0093\2\2\u0242\u0244\3\2\2\2\u0243\u023e"+
"\3\2\2\2\u0243\u023f\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0246\t\2\2\2\u0246"+
"\21\3\2\2\2\u0247\u0248\7\u00bd\2\2\u0248\u0249\7\u00c5\2\2\u0249\u024a"+
"\7\u0092\2\2\u024a\u024b\7\u00c5\2\2\u024b\u024c\7\u0093\2\2\u024c\23"+
"\3\2\2\2\u024d\u024e\7\u00bd\2\2\u024e\u0255\5\u0198\u00cd\2\u024f\u0252"+
"\7\u0092\2\2\u0250\u0253\5\26\f\2\u0251\u0253\5\32\16\2\u0252\u0250\3"+
"\2\2\2\u0252\u0251\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0254\3\2\2\2\u0254"+
"\u0256\7\u0093\2\2\u0255\u024f\3\2\2\2\u0255\u0256\3\2\2\2\u0256\25\3"+
"\2\2\2\u0257\u025c\5\30\r\2\u0258\u0259\7\u0099\2\2\u0259\u025b\5\30\r"+
"\2\u025a\u0258\3\2\2\2\u025b\u025e\3\2\2\2\u025c\u025a\3\2\2\2\u025c\u025d"+
"\3\2\2\2\u025d\27\3\2\2\2\u025e\u025c\3\2\2\2\u025f\u0260\5\u01c8\u00e5"+
"\2\u0260\u0261\7\u008f\2\2\u0261\u0262\5\32\16\2\u0262\31\3\2\2\2\u0263"+
"\u0269\5\24\13\2\u0264\u0269\5\34\17\2\u0265\u0269\5\u01e6\u00f4\2\u0266"+
"\u0269\7\u00c5\2\2\u0267\u0269\5\u0198\u00cd\2\u0268\u0263\3\2\2\2\u0268"+
"\u0264\3\2\2\2\u0268\u0265\3\2\2\2\u0268\u0266\3\2\2\2\u0268\u0267\3\2"+
"\2\2\u0269\33\3\2\2\2\u026a\u0273\7\u0096\2\2\u026b\u0270\5\32\16\2\u026c"+
"\u026d\7\u0099\2\2\u026d\u026f\5\32\16\2\u026e\u026c\3\2\2\2\u026f\u0272"+
"\3\2\2\2\u0270\u026e\3\2\2\2\u0270\u0271\3\2\2\2\u0271\u0274\3\2\2\2\u0272"+
"\u0270\3\2\2\2\u0273\u026b\3\2\2\2\u0273\u0274\3\2\2\2\u0274\u0276\3\2"+
"\2\2\u0275\u0277\7\u0099\2\2\u0276\u0275\3\2\2\2\u0276\u0277\3\2\2\2\u0277"+
"\u0278\3\2\2\2\u0278\u0279\7\u0097\2\2\u0279\35\3\2\2\2\u027a\u027c\5"+
" \21\2\u027b\u027a\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u028b\3\2\2\2\u027d"+
"\u028c\5\"\22\2\u027e\u028c\5N(\2\u027f\u028c\5R*\2\u0280\u028c\5X-\2"+
"\u0281\u028c\5Z.\2\u0282\u028c\5j\66\2\u0283\u028c\5\u0092J\2\u0284\u028c"+
"\5\u0094K\2\u0285\u028c\5$\23\2\u0286\u028c\5(\25\2\u0287\u028c\5t;\2"+
"\u0288\u028c\5n8\2\u0289\u028c\5p9\2\u028a\u028c\5r:\2\u028b\u027d\3\2"+
"\2\2\u028b\u027e\3\2\2\2\u028b\u027f\3\2\2\2\u028b\u0280\3\2\2\2\u028b"+
"\u0281\3\2\2\2\u028b\u0282\3\2\2\2\u028b\u0283\3\2\2\2\u028b\u0284\3\2"+
"\2\2\u028b\u0285\3\2\2\2\u028b\u0286\3\2\2\2\u028b\u0287\3\2\2\2\u028b"+
"\u0288\3\2\2\2\u028b\u0289\3\2\2\2\u028b\u028a\3\2\2\2\u028c\u028e\3\2"+
"\2\2\u028d\u028f\5\u00d0i\2\u028e\u028d\3\2\2\2\u028e\u028f\3\2\2\2\u028f"+
"\37\3\2\2\2\u0290\u0291\7\u0082\2\2\u0291\u0292\7\u00c5\2\2\u0292!\3\2"+
"\2\2\u0293\u0294\7\65\2\2\u0294\u0296\5\u00aeX\2\u0295\u0293\3\2\2\2\u0295"+
"\u0296\3\2\2\2\u0296\u0299\3\2\2\2\u0297\u0298\7\64\2\2\u0298\u029a\5"+
"\u00b0Y\2\u0299\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029b\3\2\2\2"+
"\u029b\u029c\7\32\2\2\u029c\u029f\5\u00c2b\2\u029d\u029e\7 \2\2\u029e"+
"\u02a0\5\u00b4[\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a2"+
"\3\2\2\2\u02a1\u02a3\5\u0100\u0081\2\u02a2\u02a1\3\2\2\2\u02a2\u02a3\3"+
"\2\2\2\u02a3\u02a6\3\2\2\2\u02a4\u02a5\7\17\2\2\u02a5\u02a7\5\u00c0a\2"+
"\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02ab\3\2\2\2\u02a8\u02a9"+
"\7*\2\2\u02a9\u02aa\7)\2\2\u02aa\u02ac\5\u00e0q\2\u02ab\u02a8\3\2\2\2"+
"\u02ab\u02ac\3\2\2\2\u02ac\u02af\3\2\2\2\u02ad\u02ae\7+\2\2\u02ae\u02b0"+
"\5\u00f0y\2\u02af\u02ad\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b3\3\2\2"+
"\2\u02b1\u02b2\7\60\2\2\u02b2\u02b4\5\u00f2z\2\u02b3\u02b1\3\2\2\2\u02b3"+
"\u02b4\3\2\2\2\u02b4\u02b8\3\2\2\2\u02b5\u02b6\7\67\2\2\u02b6\u02b7\7"+
")\2\2\u02b7\u02b9\5\u00ecw\2\u02b8\u02b5\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9"+
"\u02bc\3\2\2\2\u02ba\u02bb\7p\2\2\u02bb\u02bd\5\u00f8}\2\u02bc\u02ba\3"+
"\2\2\2\u02bc\u02bd\3\2\2\2\u02bd#\3\2\2\2\u02be\u02bf\7\'\2\2\u02bf\u02cf"+
"\5&\24\2\u02c0\u02d0\5D#\2\u02c1\u02ca\5:\36\2\u02c2\u02c4\5> \2\u02c3"+
"\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2"+
"\2\2\u02c6\u02c8\3\2\2\2\u02c7\u02c9\5B\"\2\u02c8\u02c7\3\2\2\2\u02c8"+
"\u02c9\3\2\2\2\u02c9\u02cb\3\2\2\2\u02ca\u02c3\3\2\2\2\u02ca\u02cb\3\2"+
"\2\2\u02cb\u02d0\3\2\2\2\u02cc\u02d0\5F$\2\u02cd\u02d0\5<\37\2\u02ce\u02d0"+
"\5,\27\2\u02cf\u02c0\3\2\2\2\u02cf\u02c1\3\2\2\2\u02cf\u02cc\3\2\2\2\u02cf"+
"\u02cd\3\2\2\2\u02cf\u02ce\3\2\2\2\u02d0%\3\2\2\2\u02d1\u02d4\5\u0184"+
"\u00c3\2\u02d2\u02d4\5\u00d2j\2\u02d3\u02d1\3\2\2\2\u02d3\u02d2\3\2\2"+
"\2\u02d4\u02d8\3\2\2\2\u02d5\u02d6\7\20\2\2\u02d6\u02d9\7\u00c5\2\2\u02d7"+
"\u02d9\7\u00c5\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d8\u02d9"+
"\3\2\2\2\u02d9\'\3\2\2\2\u02da\u02db\7r\2\2\u02db\u02dc\7;\2\2\u02dc\u02dd"+
"\5*\26\2\u02dd)\3\2\2\2\u02de\u02e2\5\u0198\u00cd\2\u02df\u02e0\7\20\2"+
"\2\u02e0\u02e3\7\u00c5\2\2\u02e1\u02e3\7\u00c5\2\2\u02e2\u02df\3\2\2\2"+
"\u02e2\u02e1\3\2\2\2\u02e2\u02e3\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5"+
"\7R\2\2\u02e5\u02e8\5H%\2\u02e6\u02e7\7\17\2\2\u02e7\u02e9\5\u00c0a\2"+
"\u02e8\u02e6\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9+\3\2\2\2\u02ea\u02ec\7"+
"}\2\2\u02eb\u02ed\7\65\2\2\u02ec\u02eb\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed"+
"\u02ee\3\2\2\2\u02ee\u02f2\7\u00c5\2\2\u02ef\u02f0\7\20\2\2\u02f0\u02f3"+
"\7\u00c5\2\2\u02f1\u02f3\7\u00c5\2\2\u02f2\u02ef\3\2\2\2\u02f2\u02f1\3"+
"\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f6\3\2\2\2\u02f4\u02f5\7\17\2\2\u02f5"+
"\u02f7\5\u00c0a\2\u02f6\u02f4\3\2\2\2\u02f6\u02f7\3\2\2\2\u02f7\u02f9"+
"\3\2\2\2\u02f8\u02fa\5.\30\2\u02f9\u02f8\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb"+
"\u02f9\3\2\2\2\u02fb\u02fc\3\2\2\2\u02fc-\3\2\2\2\u02fd\u0300\5\60\31"+
"\2\u02fe\u0300\5\64\33\2\u02ff\u02fd\3\2\2\2\u02ff\u02fe\3\2\2\2\u0300"+
"/\3\2\2\2\u0301\u0302\7\35\2\2\u0302\u0305\7~\2\2\u0303\u0304\7\13\2\2"+
"\u0304\u0306\5\u0122\u0092\2\u0305\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306"+
"\u0308\3\2\2\2\u0307\u0309\5\62\32\2\u0308\u0307\3\2\2\2\u0309\u030a\3"+
"\2\2\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030b\61\3\2\2\2\u030c"+
"\u031b\7\36\2\2\u030d\u030e\7r\2\2\u030e\u030f\7R\2\2\u030f\u0310\5H%"+
"\2\u0310\u0313\3\2\2\2\u0311\u0312\7\17\2\2\u0312\u0314\5\u00c0a\2\u0313"+
"\u0311\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u031c\3\2\2\2\u0315\u0318\7P"+
"\2\2\u0316\u0317\7\17\2\2\u0317\u0319\5\u00c0a\2\u0318\u0316\3\2\2\2\u0318"+
"\u0319\3\2\2\2\u0319\u031c\3\2\2\2\u031a\u031c\58\35\2\u031b\u030d\3\2"+
"\2\2\u031b\u0315\3\2\2\2\u031b\u031a\3\2\2\2\u031c\63\3\2\2\2\u031d\u031e"+
"\7\35\2\2\u031e\u031f\7\f\2\2\u031f\u0322\7~\2\2\u0320\u0321\7\13\2\2"+
"\u0321\u0323\5\u0122\u0092\2\u0322\u0320\3\2\2\2\u0322\u0323\3\2\2\2\u0323"+
"\u0325\3\2\2\2\u0324\u0326\5\66\34\2\u0325\u0324\3\2\2\2\u0326\u0327\3"+
"\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\65\3\2\2\2\u0329"+
"\u032a\7\36\2\2\u032a\u032b\58\35\2\u032b\67\3\2\2\2\u032c\u032f\7\64"+
"\2\2\u032d\u032e\7\65\2\2\u032e\u0330\5\u0198\u00cd\2\u032f\u032d\3\2"+
"\2\2\u032f\u0330\3\2\2\2\u0330\u0335\3\2\2\2\u0331\u0332\7\u0092\2\2\u0332"+
"\u0333\5\u00b2Z\2\u0333\u0334\7\u0093\2\2\u0334\u0336\3\2\2\2\u0335\u0331"+
"\3\2\2\2\u0335\u0336\3\2\2\2\u0336\u0337\3\2\2\2\u0337\u0338\7\32\2\2"+
"\u0338\u033b\5\u00c4c\2\u0339\u033a\7\17\2\2\u033a\u033c\5\u00c0a\2\u033b"+
"\u0339\3\2\2\2\u033b\u033c\3\2\2\2\u033c9\3\2\2\2\u033d\u033e\7\64\2\2"+
"\u033e\u0340\5\u00b0Y\2\u033f\u033d\3\2\2\2\u033f\u0340\3\2\2\2\u0340"+
"\u0341\3\2\2\2\u0341\u0346\7\32\2\2\u0342\u0344\7\13\2\2\u0343\u0342\3"+
"\2\2\2\u0343\u0344\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0347\7P\2\2\u0346"+
"\u0343\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0349\3\2\2\2\u0348\u034a\7,"+
"\2\2\u0349\u0348\3\2\2\2\u0349\u034a\3\2\2\2\u034a\u034b\3\2\2\2\u034b"+
"\u034d\5\u00c4c\2\u034c\u034e\5L\'\2\u034d\u034c\3\2\2\2\u034d\u034e\3"+
"\2\2\2\u034e\u0351\3\2\2\2\u034f\u0350\7\17\2\2\u0350\u0352\5\u00c0a\2"+
"\u0351\u034f\3\2\2\2\u0351\u0352\3\2\2\2\u0352\u0356\3\2\2\2\u0353\u0354"+
"\7*\2\2\u0354\u0355\7)\2\2\u0355\u0357\5\u00e0q\2\u0356\u0353\3\2\2\2"+
"\u0356\u0357\3\2\2\2\u0357\u035a\3\2\2\2\u0358\u0359\7+\2\2\u0359\u035b"+
"\5\u00f0y\2\u035a\u0358\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u035f\3\2\2"+
"\2\u035c\u035d\7\67\2\2\u035d\u035e\7)\2\2\u035e\u0360\5\u00ecw\2\u035f"+
"\u035c\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0363\3\2\2\2\u0361\u0362\7p"+
"\2\2\u0362\u0364\5\u00f8}\2\u0363\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364"+
";\3\2\2\2\u0365\u0366\7r\2\2\u0366\u036a\7\u00c5\2\2\u0367\u0368\7\20"+
"\2\2\u0368\u036b\7\u00c5\2\2\u0369\u036b\7\u00c5\2\2\u036a\u0367\3\2\2"+
"\2\u036a\u0369\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d"+
"\7R\2\2\u036d\u0370\5H%\2\u036e\u036f\7\17\2\2\u036f\u0371\5\u00c0a\2"+
"\u0370\u036e\3\2\2\2\u0370\u0371\3\2\2\2\u0371=\3\2\2\2\u0372\u0373\7"+
"\64\2\2\u0373\u0374\5\u00b0Y\2\u0374\u0375\7\32\2\2\u0375\u0377\5\u00c4"+
"c\2\u0376\u0378\5@!\2\u0377\u0376\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u037b"+
"\3\2\2\2\u0379\u037a\7\17\2\2\u037a\u037c\5\u00c0a\2\u037b\u0379\3\2\2"+
"\2\u037b\u037c\3\2\2\2\u037c?\3\2\2\2\u037d\u037e\7 \2\2\u037e\u0382\5"+
"\u0186\u00c4\2\u037f\u0380\7\20\2\2\u0380\u0383\7\u00c5\2\2\u0381\u0383"+
"\7\u00c5\2\2\u0382\u037f\3\2\2\2\u0382\u0381\3\2\2\2\u0382\u0383\3\2\2"+
"\2\u0383A\3\2\2\2\u0384\u0387\7\60\2\2\u0385\u0388\7\62\2\2\u0386\u0388"+
"\7-\2\2\u0387\u0385\3\2\2\2\u0387\u0386\3\2\2\2\u0388C\3\2\2\2\u0389\u038a"+
"\7P\2\2\u038a\u038d\5L\'\2\u038b\u038c\7\17\2\2\u038c\u038e\5\u00c0a\2"+
"\u038d\u038b\3\2\2\2\u038d\u038e\3\2\2\2\u038eE\3\2\2\2\u038f\u0390\7"+
"R\2\2\u0390\u0391\5H%\2\u0391G\3\2\2\2\u0392\u0397\5J&\2\u0393\u0394\7"+
"\u0099\2\2\u0394\u0396\5J&\2\u0395\u0393\3\2\2\2\u0396\u0399\3\2\2\2\u0397"+
"\u0395\3\2\2\2\u0397\u0398\3\2\2\2\u0398I\3\2\2\2\u0399\u0397\3\2\2\2"+
"\u039a\u039b\5\u01c2\u00e2\2\u039b\u039c\7\u008f\2\2\u039c\u039d\5\u0122"+
"\u0092\2\u039d\u03a0\3\2\2\2\u039e\u03a0\5\u0122\u0092\2\u039f\u039a\3"+
"\2\2\2\u039f\u039e\3\2\2\2\u03a0K\3\2\2\2\u03a1\u03a2\7 \2\2\u03a2\u03a6"+
"\7\u00c5\2\2\u03a3\u03a4\7\20\2\2\u03a4\u03a7\7\u00c5\2\2\u03a5\u03a7"+
"\7\u00c5\2\2\u03a6\u03a3\3\2\2\2\u03a6\u03a5\3\2\2\2\u03a6\u03a7\3\2\2"+
"\2\u03a7M\3\2\2\2\u03a8\u03a9\7\3\2\2\u03a9\u03aa\7\4\2\2\u03aa\u03ac"+
"\7\u00c5\2\2\u03ab\u03ad\5\u00d8m\2\u03ac\u03ab\3\2\2\2\u03ac\u03ad\3"+
"\2\2\2\u03ad\u03b0\3\2\2\2\u03ae\u03b1\7?\2\2\u03af\u03b1\7@\2\2\u03b0"+
"\u03ae\3\2\2\2\u03b0\u03af\3\2\2\2\u03b0\u03b1\3\2\2\2\u03b1\u03b3\3\2"+
"\2\2\u03b2\u03b4\7\20\2\2\u03b3\u03b2\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4"+
"\u03ba\3\2\2\2\u03b5\u03bb\5P)\2\u03b6\u03b7\7\u0092\2\2\u03b7\u03b8\5"+
"b\62\2\u03b8\u03b9\7\u0093\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03b5\3\2\2\2"+
"\u03ba\u03b6\3\2\2\2\u03bb\u03c1\3\2\2\2\u03bc\u03bf\7\64\2\2\u03bd\u03be"+
"\7\17\2\2\u03be\u03c0\5\u0122\u0092\2\u03bf\u03bd\3\2\2\2\u03bf\u03c0"+
"\3\2\2\2\u03c0\u03c2\3\2\2\2\u03c1\u03bc\3\2\2\2\u03c1\u03c2\3\2\2\2\u03c2"+
"O\3\2\2\2\u03c3\u03c4\7\32\2\2\u03c4\u03c5\5f\64\2\u03c5\u03c6\7 \2\2"+
"\u03c6\u03c8\3\2\2\2\u03c7\u03c3\3\2\2\2\u03c7\u03c8\3\2\2\2\u03c8\u03c9"+
"\3\2\2\2\u03c9\u03ca\5\u0198\u00cd\2\u03caQ\3\2\2\2\u03cb\u03cd\7\3\2"+
"\2\u03cc\u03ce\7\u00c5\2\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce"+
"\u03cf\3\2\2\2\u03cf\u03d0\7W\2\2\u03d0\u03d1\7\u00c5\2\2\u03d1\u03d2"+
"\7\'\2\2\u03d2\u03d3\7\u00c5\2\2\u03d3\u03d4\7\u0092\2\2\u03d4\u03d5\5"+
"T+\2\u03d5\u03d6\7\u0093\2\2\u03d6S\3\2\2\2\u03d7\u03dc\5V,\2\u03d8\u03d9"+
"\7\u0099\2\2\u03d9\u03db\5V,\2\u03da\u03d8\3\2\2\2\u03db\u03de\3\2\2\2"+
"\u03dc\u03da\3\2\2\2\u03dc\u03dd\3\2\2\2\u03ddU\3\2\2\2\u03de\u03dc\3"+
"\2\2\2\u03df\u03e6\5\u0122\u0092\2\u03e0\u03e2\7\u0092\2\2\u03e1\u03e3"+
"\5\u01a8\u00d5\2\u03e2\u03e1\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3\u03e4\3"+
"\2\2\2\u03e4\u03e6\7\u0093\2\2\u03e5\u03df\3\2\2\2\u03e5\u03e0\3\2\2\2"+
"\u03e6\u03ef\3\2\2\2\u03e7\u03ed\7\u00c5\2\2\u03e8\u03ea\7\u0092\2\2\u03e9"+
"\u03eb\5\u01a8\u00d5\2\u03ea\u03e9\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec"+
"\3\2\2\2\u03ec\u03ee\7\u0093\2\2\u03ed\u03e8\3\2\2\2\u03ed\u03ee\3\2\2"+
"\2\u03ee\u03f0\3\2\2\2\u03ef\u03e7\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0W"+
"\3\2\2\2\u03f1\u03f3\7\3\2\2\u03f2\u03f4\7\u00c5\2\2\u03f3\u03f2\3\2\2"+
"\2\u03f3\u03f4\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f6\7S\2\2\u03f6\u03fc"+
"\5\u0198\u00cd\2\u03f7\u03f9\7\u0094\2\2\u03f8\u03fa\7\u00c5\2\2\u03f9"+
"\u03f8\3\2\2\2\u03f9\u03fa\3\2\2\2\u03fa\u03fb\3\2\2\2\u03fb\u03fd\7\u0095"+
"\2\2\u03fc\u03f7\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03fe\3\2\2\2\u03fe"+
"\u0401\7\u00c5\2\2\u03ff\u0400\7\u008f\2\2\u0400\u0402\5\u0122\u0092\2"+
"\u0401\u03ff\3\2\2\2\u0401\u0402\3\2\2\2\u0402Y\3\2\2\2\u0403\u0404\7"+
"\3\2\2\u0404\u0405\7T\2\2\u0405\u0407\7\u00c5\2\2\u0406\u0408\7\20\2\2"+
"\u0407\u0406\3\2\2\2\u0407\u0408\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u040a"+
"\7\u0092\2\2\u040a\u040b\5\\/\2\u040b\u040c\7\u0093\2\2\u040c[\3\2\2\2"+
"\u040d\u0412\5^\60\2\u040e\u040f\7\u0099\2\2\u040f\u0411\5^\60\2\u0410"+
"\u040e\3\2\2\2\u0411\u0414\3\2\2\2\u0412\u0410\3\2\2\2\u0412\u0413\3\2"+
"\2\2\u0413]\3\2\2\2\u0414\u0412\3\2\2\2\u0415\u0419\7\u00c5\2\2\u0416"+
"\u041a\5`\61\2\u0417\u041a\5\u014e\u00a8\2\u0418\u041a\5\u0154\u00ab\2"+
"\u0419\u0416\3\2\2\2\u0419\u0417\3\2\2\2\u0419\u0418\3\2\2\2\u041a\u041c"+
"\3\2\2\2\u041b\u041d\7\u00c5\2\2\u041c\u041b\3\2\2\2\u041c\u041d\3\2\2"+
"\2\u041d\u041f\3\2\2\2\u041e\u0420\7\u00c5\2\2\u041f\u041e\3\2\2\2\u041f"+
"\u0420\3\2\2\2\u0420\u0425\3\2\2\2\u0421\u0424\5\u0192\u00ca\2\u0422\u0424"+
"\5\24\13\2\u0423\u0421\3\2\2\2\u0423\u0422\3\2\2\2\u0424\u0427\3\2\2\2"+
"\u0425\u0423\3\2\2\2\u0425\u0426\3\2\2\2\u0426_\3\2\2\2\u0427\u0425\3"+
"\2\2\2\u0428\u042e\5\u0198\u00cd\2\u0429\u042b\7\u0094\2\2\u042a\u042c"+
"\7\u00c5\2\2\u042b\u042a\3\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2"+
"\2\u042d\u042f\7\u0095\2\2\u042e\u0429\3\2\2\2\u042e\u042f\3\2\2\2\u042f"+
"a\3\2\2\2\u0430\u0435\5d\63\2\u0431\u0432\7\u0099\2\2\u0432\u0434\5d\63"+
"\2\u0433\u0431\3\2\2\2\u0434\u0437\3\2\2\2\u0435\u0433\3\2\2\2\u0435\u0436"+
"\3\2\2\2\u0436c\3\2\2\2\u0437\u0435\3\2\2\2\u0438\u0442\5\u0198\u00cd"+
"\2\u0439\u0443\7o\2\2\u043a\u0440\5\u0198\u00cd\2\u043b\u043d\7\u0094"+
"\2\2\u043c\u043e\7\u00c5\2\2\u043d\u043c\3\2\2\2\u043d\u043e\3\2\2\2\u043e"+
"\u043f\3\2\2\2\u043f\u0441\7\u0095\2\2\u0440\u043b\3\2\2\2\u0440\u0441"+
"\3\2\2\2\u0441\u0443\3\2\2\2\u0442\u0439\3\2\2\2\u0442\u043a\3\2\2\2\u0443"+
"e\3\2\2\2\u0444\u0449\5h\65\2\u0445\u0446\7\u0099\2\2\u0446\u0448\5h\65"+
"\2\u0447\u0445\3\2\2\2\u0448\u044b\3\2\2\2\u0449\u0447\3\2\2\2\u0449\u044a"+
"\3\2\2\2\u044ag\3\2\2\2\u044b\u0449\3\2\2\2\u044c\u0457\7\u00a6\2\2\u044d"+
"\u0450\5\u01c2\u00e2\2\u044e\u044f\7\20\2\2\u044f\u0451\7\u00c5\2\2\u0450"+
"\u044e\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u0457\3\2\2\2\u0452\u0453\5\u01e6"+
"\u00f4\2\u0453\u0454\7\20\2\2\u0454\u0455\7\u00c5\2\2\u0455\u0457\3\2"+
"\2\2\u0456\u044c\3\2\2\2\u0456\u044d\3\2\2\2\u0456\u0452\3\2\2\2\u0457"+
"i\3\2\2\2\u0458\u045a\7\3\2\2\u0459\u045b\7\u00c5\2\2\u045a\u0459\3\2"+
"\2\2\u045a\u045b\3\2\2\2\u045b\u045c\3\2\2\2\u045c\u045d\5l\67\2\u045d"+
"k\3\2\2\2\u045e\u045f\7=\2\2\u045f\u0461\7\u00c5\2\2\u0460\u0462\7\20"+
"\2\2\u0461\u0460\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0469\3\2\2\2\u0463"+
"\u046a\5\u00aaV\2\u0464\u0466\7\u0092\2\2\u0465\u0467\5b\62\2\u0466\u0465"+
"\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u046a\7\u0093\2"+
"\2\u0469\u0463\3\2\2\2\u0469\u0464\3\2\2\2\u046a\u046e\3\2\2\2\u046b\u046d"+
"\5\u00a8U\2\u046c\u046b\3\2\2\2\u046d\u0470\3\2\2\2\u046e\u046c\3\2\2"+
"\2\u046e\u046f\3\2\2\2\u046fm\3\2\2\2\u0470\u046e\3\2\2\2\u0471\u0472"+
"\7P\2\2\u0472\u0473\7 \2\2\u0473\u0477\5\u0198\u00cd\2\u0474\u0475\7\20"+
"\2\2\u0475\u0478\7\u00c5\2\2\u0476\u0478\7\u00c5\2\2\u0477\u0474\3\2\2"+
"\2\u0477\u0476\3\2\2\2\u0477\u0478\3\2\2\2\u0478\u047b\3\2\2\2\u0479\u047a"+
"\7\17\2\2\u047a\u047c\5\u00c0a\2\u047b\u0479\3\2\2\2\u047b\u047c\3\2\2"+
"\2\u047co\3\2\2\2\u047d\u047e\7r\2\2\u047e\u047f\5*\26\2\u047fq\3\2\2"+
"\2\u0480\u0481\7\64\2\2\u0481\u0482\5\u00b0Y\2\u0482\u0483\7\66\2\2\u0483"+
"\u0484\7\u0092\2\2\u0484\u0485\5\u01a8\u00d5\2\u0485\u0486\7\u0093\2\2"+
"\u0486s\3\2\2\2\u0487\u0488\7\3\2\2\u0488\u0489\7\u0085\2\2\u0489\u048b"+
"\7\u00c5\2\2\u048a\u048c\7\20\2\2\u048b\u048a\3\2\2\2\u048b\u048c\3\2"+
"\2\2\u048c\u048d\3\2\2\2\u048d\u048e\5v<\2\u048eu\3\2\2\2\u048f\u0493"+
"\5x=\2\u0490\u0492\5x=\2\u0491\u0490\3\2\2\2\u0492\u0495\3\2\2\2\u0493"+
"\u0491\3\2\2\2\u0493\u0494\3\2\2\2\u0494w\3\2\2\2\u0495\u0493\3\2\2\2"+
"\u0496\u0498\5\24\13\2\u0497\u0496\3\2\2\2\u0498\u049b\3\2\2\2\u0499\u0497"+
"\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049e\3\2\2\2\u049b\u0499\3\2\2\2\u049c"+
"\u049f\7\u00c5\2\2\u049d\u049f\7\32\2\2\u049e\u049c\3\2\2\2\u049e\u049d"+
"\3\2\2\2\u049f\u04a1\3\2\2\2\u04a0\u04a2\5z>\2\u04a1\u04a0\3\2\2\2\u04a1"+
"\u04a2\3\2\2\2\u04a2\u04a4\3\2\2\2\u04a3\u04a5\5\u0084C\2\u04a4\u04a3"+
"\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04a8\7\u0096\2"+
"\2\u04a7\u04a9\5\u008eH\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9"+
"\u04ab\3\2\2\2\u04aa\u04ac\7\u0099\2\2\u04ab\u04aa\3\2\2\2\u04ab\u04ac"+
"\3\2\2\2\u04ac\u04ad\3\2\2\2\u04ad\u04b2\7\u0097\2\2\u04ae\u04af\5j\66"+
"\2\u04af\u04b0\7\u0099\2\2\u04b0\u04b2\3\2\2\2\u04b1\u0499\3\2\2\2\u04b1"+
"\u04ae\3\2\2\2\u04b2y\3\2\2\2\u04b3\u04b4\7\u0092\2\2\u04b4\u04b5\5|?"+
"\2\u04b5\u04b6\7\u0093\2\2\u04b6{\3\2\2\2\u04b7\u04bc\5~@\2\u04b8\u04b9"+
"\7\u0099\2\2\u04b9\u04bb\5~@\2\u04ba\u04b8\3\2\2\2\u04bb\u04be\3\2\2\2"+
"\u04bc\u04ba\3\2\2\2\u04bc\u04bd\3\2\2\2\u04bd}\3\2\2\2\u04be\u04bc\3"+
"\2\2\2\u04bf\u04c2\5\u0198\u00cd\2\u04c0\u04c2\5\u0080A\2\u04c1\u04bf"+
"\3\2\2\2\u04c1\u04c0\3\2\2\2\u04c2\u04c4\3\2\2\2\u04c3\u04c5\5\u0082B"+
"\2\u04c4\u04c3\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\177\3\2\2\2\u04c6\u04c7"+
"\7\u0092\2\2\u04c7\u04c8\5\u0198\u00cd\2\u04c8\u04c9\7\u0099\2\2\u04c9"+
"\u04ca\5\u0198\u00cd\2\u04ca\u04cb\3\2\2\2\u04cb\u04cc\7\u0093\2\2\u04cc"+
"\u0081\3\2\2\2\u04cd\u04ce\7\20\2\2\u04ce\u04cf\7\u00c5\2\2\u04cf\u0083"+
"\3\2\2\2\u04d0\u04d1\7\u008d\2\2\u04d1\u04d6\5\u0086D\2\u04d2\u04d3\7"+
"\u0099\2\2\u04d3\u04d5\5\u0086D\2\u04d4\u04d2\3\2\2\2\u04d5\u04d8\3\2"+
"\2\2\u04d6\u04d4\3\2\2\2\u04d6\u04d7\3\2\2\2\u04d7\u0085\3\2\2\2\u04d8"+
"\u04d6\3\2\2\2\u04d9\u04db\5\u0198\u00cd\2\u04da\u04dc\5\u0088E\2\u04db"+
"\u04da\3\2\2\2\u04db\u04dc\3\2\2\2\u04dc\u0087\3\2\2\2\u04dd\u04de\7\u00ad"+
"\2\2\u04de\u04e3\5\u008aF\2\u04df\u04e0\7\u0099\2\2\u04e0\u04e2\5\u008a"+
"F\2\u04e1\u04df\3\2\2\2\u04e2\u04e5\3\2\2\2\u04e3\u04e1\3\2\2\2\u04e3"+
"\u04e4\3\2\2\2\u04e4\u04e6\3\2\2\2\u04e5\u04e3\3\2\2\2\u04e6\u04e7\7\u00ab"+
"\2\2\u04e7\u0089\3\2\2\2\u04e8\u04eb\5\u008cG\2\u04e9\u04eb\7\u0091\2"+
"\2\u04ea\u04e8\3\2\2\2\u04ea\u04e9\3\2\2\2\u04eb\u008b\3\2\2\2\u04ec\u04ee"+
"\5\u0198\u00cd\2\u04ed\u04ef\5\u0088E\2\u04ee\u04ed\3\2\2\2\u04ee\u04ef"+
"\3\2\2\2\u04ef\u008d\3\2\2\2\u04f0\u04f5\5\u0090I\2\u04f1\u04f2\7\u0099"+
"\2\2\u04f2\u04f4\5\u0090I\2\u04f3\u04f1\3\2\2\2\u04f4\u04f7\3\2\2\2\u04f5"+
"\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6\u008f\3\2\2\2\u04f7\u04f5\3\2"+
"\2\2\u04f8\u04f9\7\32\2\2\u04f9\u04fa\t\3\2\2\u04fa\u04fb\7\u0092\2\2"+
"\u04fb\u04fc\5\"\22\2\u04fc\u04fd\7\u0093\2\2\u04fd\u0506\3\2\2\2\u04fe"+
"\u04ff\7\u00c5\2\2\u04ff\u0503\t\3\2\2\u0500\u0504\5\u0122\u0092\2\u0501"+
"\u0504\5\u01ee\u00f8\2\u0502\u0504\5\u01f0\u00f9\2\u0503\u0500\3\2\2\2"+
"\u0503\u0501\3\2\2\2\u0503\u0502\3\2\2\2\u0504\u0506\3\2\2\2\u0505\u04f8"+
"\3\2\2\2\u0505\u04fe\3\2\2\2\u0506\u0091\3\2\2\2\u0507\u0508\7\3\2\2\u0508"+
"\u0509\7\u0082\2\2\u0509\u050b\7\u00c5\2\2\u050a\u050c\7\20\2\2\u050b"+
"\u050a\3\2\2\2\u050b\u050c\3\2\2\2\u050c\u050d\3\2\2\2\u050d\u050e\5\u0096"+
"L\2\u050e\u0093\3\2\2\2\u050f\u0510\7\3\2\2\u0510\u0511\5\n\6\2\u0511"+
"\u0095\3\2\2\2\u0512\u051e\5\u009aN\2\u0513\u0514\5\u0098M\2\u0514\u0515"+
"\7\u0099\2\2\u0515\u051a\5\u0098M\2\u0516\u0517\7\u0099\2\2\u0517\u0519"+
"\5\u0098M\2\u0518\u0516\3\2\2\2\u0519\u051c\3\2\2\2\u051a\u0518\3\2\2"+
"\2\u051a\u051b\3\2\2\2\u051b\u051e\3\2\2\2\u051c\u051a\3\2\2\2\u051d\u0512"+
"\3\2\2\2\u051d\u0513\3\2\2\2\u051e\u0097\3\2\2\2\u051f\u0520\7\u0082\2"+
"\2\u0520\u0522\7\u00c5\2\2\u0521\u0523\7\20\2\2\u0522\u0521\3\2\2\2\u0522"+
"\u0523\3\2\2\2\u0523\u0524\3\2\2\2\u0524\u0525\5\u009aN\2\u0525\u0099"+
"\3\2\2\2\u0526\u052a\7\u0081\2\2\u0527\u0528\7\u00bd\2\2\u0528\u052b\7"+
"\u00c5\2\2\u0529\u052b\5\u009eP\2\u052a\u0527\3\2\2\2\u052a\u0529\3\2"+
"\2\2\u052b\u052e\3\2\2\2\u052c\u052d\7\37\2\2\u052d\u052f\5\u009eP\2\u052e"+
"\u052c\3\2\2\2\u052e\u052f\3\2\2\2\u052f\u056d\3\2\2\2\u0530\u0532\7\u0083"+
"\2\2\u0531\u0533\7)\2\2\u0532\u0531\3\2\2\2\u0532\u0533\3\2\2\2\u0533"+
"\u0535\3\2\2\2\u0534\u0536\5\u009cO\2\u0535\u0534\3\2\2\2\u0535\u0536"+
"\3\2\2\2\u0536\u053a\3\2\2\2\u0537\u0538\7\u00bd\2\2\u0538\u0539\7\u00c5"+
"\2\2\u0539\u053b\7\13\2\2\u053a\u0537\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
"\u053c\3\2\2\2\u053c\u0542\5\u009eP\2\u053d\u053f\7\u0084\2\2\u053e\u0540"+
"\7)\2\2\u053f\u053e\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0541\3\2\2\2\u0541"+
"\u0543\5\u009eP\2\u0542\u053d\3\2\2\2\u0542\u0543\3\2\2\2\u0543\u056d"+
"\3\2\2\2\u0544\u0546\7w\2\2\u0545\u0547\7)\2\2\u0546\u0545\3\2\2\2\u0546"+
"\u0547\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u054d\5\u00a2R\2\u0549\u054a"+
"\7\u0099\2\2\u054a\u054c\5\u00a2R\2\u054b\u0549\3\2\2\2\u054c\u054f\3"+
"\2\2\2\u054d\u054b\3\2\2\2\u054d\u054e\3\2\2\2\u054e\u056d\3\2\2\2\u054f"+
"\u054d\3\2\2\2\u0550\u0555\5\u00a6T\2\u0551\u0552\7\u0099\2\2\u0552\u0554"+
"\5\u00a6T\2\u0553\u0551\3\2\2\2\u0554\u0557\3\2\2\2\u0555\u0553\3\2\2"+
"\2\u0555\u0556\3\2\2\2\u0556\u0558\3\2\2\2\u0557\u0555\3\2\2\2\u0558\u0559"+
"\7 \2\2\u0559\u055a\5\u0184\u00c3\2\u055a\u056d\3\2\2\2\u055b\u055d\7"+
"\25\2\2\u055c\u055e\7)\2\2\u055d\u055c\3\2\2\2\u055d\u055e\3\2\2\2\u055e"+
"\u055f\3\2\2\2\u055f\u0564\5\u00a4S\2\u0560\u0561\7\u0099\2\2\u0561\u0563"+
"\5\u00a4S\2\u0562\u0560\3\2\2\2\u0563\u0566\3\2\2\2\u0564\u0562\3\2\2"+
"\2\u0564\u0565\3\2\2\2\u0565\u0567\3\2\2\2\u0566\u0564\3\2\2\2\u0567\u0568"+
"\7\u00c5\2\2\u0568\u056a\5\u01e2\u00f2\2\u0569\u056b\7\u00c5\2\2\u056a"+
"\u0569\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u056d\3\2\2\2\u056c\u0526\3\2"+
"\2\2\u056c\u0530\3\2\2\2\u056c\u0544\3\2\2\2\u056c\u0550\3\2\2\2\u056c"+
"\u055b\3\2\2\2\u056d\u009b\3\2\2\2\u056e\u056f\7,\2\2\u056f\u0571\7\u0092"+
"\2\2\u0570\u0572\5\u01a8\u00d5\2\u0571\u0570\3\2\2\2\u0571\u0572\3\2\2"+
"\2\u0572\u0573\3\2\2\2\u0573\u0574\7\u0093\2\2\u0574\u009d\3\2\2\2\u0575"+
"\u057f\5\u00a0Q\2\u0576\u0579\5\u00d2j\2\u0577\u0578\7\u00bd\2\2\u0578"+
"\u057a\7\u00c5\2\2\u0579\u0577\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057f"+
"\3\2\2\2\u057b\u057f\5\u00fa~\2\u057c\u057d\7y\2\2\u057d\u057f\5\u01ce"+
"\u00e8\2\u057e\u0575\3\2\2\2\u057e\u0576\3\2\2\2\u057e\u057b\3\2\2\2\u057e"+
"\u057c\3\2\2\2\u057f\u009f\3\2\2\2\u0580\u0585\5\u0184\u00c3\2\u0581\u0583"+
"\7\20\2\2\u0582\u0581\3\2\2\2\u0582\u0583\3\2\2\2\u0583\u0584\3\2\2\2"+
"\u0584\u0586\7\u00c5\2\2\u0585\u0582\3\2\2\2\u0585\u0586\3\2\2\2\u0586"+
"\u00a1\3\2\2\2\u0587\u058c\5\u01c2\u00e2\2\u0588\u0589\t\4\2\2\u0589\u058b"+
"\5\u01c2\u00e2\2\u058a\u0588\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3"+
"\2\2\2\u058c\u058d\3\2\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f"+
"\u0590\7 \2\2\u0590\u0591\5\u0184\u00c3\2\u0591\u00a3\3\2\2\2\u0592\u0593"+
"\5\u0158\u00ad\2\u0593\u0594\7 \2\2\u0594\u0595\5\u0184\u00c3\2\u0595"+
"\u00a5\3\2\2\2\u0596\u0598\7*\2\2\u0597\u0599\7)\2\2\u0598\u0597\3\2\2"+
"\2\u0598\u0599\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059b\5\u0122\u0092\2"+
"\u059b\u059c\7\20\2\2\u059c\u059d\7\u00c5\2\2\u059d\u00a7\3\2\2\2\u059e"+
"\u059f\7\u00c5\2\2\u059f\u05a0\5\u00b2Z\2\u05a0\u00a9\3\2\2\2\u05a1\u05a6"+
"\5\u00acW\2\u05a2\u05a3\7\u0099\2\2\u05a3\u05a5\5\u00acW\2\u05a4\u05a2"+
"\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7"+
"\u00ab\3\2\2\2\u05a8\u05a6\3\2\2\2\u05a9\u05ac\7\u00a6\2\2\u05aa\u05ac"+
"\5\u0198\u00cd\2\u05ab\u05a9\3\2\2\2\u05ab\u05aa\3\2\2\2\u05ac\u00ad\3"+
"\2\2\2\u05ad\u05ae\7T\2\2\u05ae\u05af\7\u00c5\2\2\u05af\u00af\3\2\2\2"+
"\u05b0\u05b4\7;\2\2\u05b1\u05b4\7:\2\2\u05b2\u05b4\7<\2\2\u05b3\u05b0"+
"\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3\u05b2\3\2\2\2\u05b3\u05b4\3\2\2\2\u05b4"+
"\u05b5\3\2\2\2\u05b5\u05b6\7\65\2\2\u05b6\u05bc\5\u0198\u00cd\2\u05b7"+
"\u05b9\7\u0092\2\2\u05b8\u05ba\5\u00b2Z\2\u05b9\u05b8\3\2\2\2\u05b9\u05ba"+
"\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bd\7\u0093\2\2\u05bc\u05b7\3\2\2"+
"\2\u05bc\u05bd\3\2\2\2\u05bd\u00b1\3\2\2\2\u05be\u05c3\7\u00c5\2\2\u05bf"+
"\u05c0\7\u0099\2\2\u05c0\u05c2\7\u00c5\2\2\u05c1\u05bf\3\2\2\2\u05c2\u05c5"+
"\3\2\2\2\u05c3\u05c1\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4\u00b3\3\2\2\2\u05c5"+
"\u05c3\3\2\2\2\u05c6\u05c9\5\u00ceh\2\u05c7\u05ca\5\u00b6\\\2\u05c8\u05ca"+
"\5\u00b8]\2\u05c9\u05c7\3\2\2\2\u05c9\u05c8\3\2\2\2\u05ca\u00b5\3\2\2"+
"\2\u05cb\u05cc\7\u0099\2\2\u05cc\u05ce\5\u00ceh\2\u05cd\u05cb\3\2\2\2"+
"\u05ce\u05d1\3\2\2\2\u05cf\u05cd\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u00b7"+
"\3\2\2\2\u05d1\u05cf\3\2\2\2\u05d2\u05d6\5\u00ba^\2\u05d3\u05d5\5\u00ba"+
"^\2\u05d4\u05d3\3\2\2\2\u05d5\u05d8\3\2\2\2\u05d6\u05d4\3\2\2\2\u05d6"+
"\u05d7\3\2\2\2\u05d7\u00b9\3\2\2\2\u05d8\u05d6\3\2\2\2\u05d9\u05dd\7$"+
"\2\2\u05da\u05dd\7%\2\2\u05db\u05dd\7&\2\2\u05dc\u05d9\3\2\2\2\u05dc\u05da"+
"\3\2\2\2\u05dc\u05db\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u05e0\7!\2\2\u05df"+
"\u05dc\3\2\2\2\u05df\u05e0\3\2\2\2\u05e0\u05e3\3\2\2\2\u05e1\u05e3\7\""+
"\2\2\u05e2\u05df\3\2\2\2\u05e2\u05e1\3\2\2\2\u05e3\u05e4\3\2\2\2\u05e4"+
"\u05e5\7#\2\2\u05e5\u05e7\5\u00ceh\2\u05e6\u05e8\5\u00bc_\2\u05e7\u05e6"+
"\3\2\2\2\u05e7\u05e8\3\2\2\2\u05e8\u00bb\3\2\2\2\u05e9\u05ea\7\'\2\2\u05ea"+
"\u05ef\5\u00be`\2\u05eb\u05ec\7\13\2\2\u05ec\u05ee\5\u00be`\2\u05ed\u05eb"+
"\3\2\2\2\u05ee\u05f1\3\2\2\2\u05ef\u05ed\3\2\2\2\u05ef\u05f0\3\2\2\2\u05f0"+
"\u00bd\3\2\2\2\u05f1\u05ef\3\2\2\2\u05f2\u05f3\5\u01c2\u00e2\2\u05f3\u05f4"+
"\7\u008f\2\2\u05f4\u05f5\5\u01c2\u00e2\2\u05f5\u00bf\3\2\2\2\u05f6\u05f7"+
"\5\u0126\u0094\2\u05f7\u00c1\3\2\2\2\u05f8\u05fc\7:\2\2\u05f9\u05fc\7"+
";\2\2\u05fa\u05fc\7<\2\2\u05fb\u05f8\3\2\2\2\u05fb\u05f9\3\2\2\2\u05fb"+
"\u05fa\3\2\2\2\u05fb\u05fc\3\2\2\2\u05fc\u05fe\3\2\2\2\u05fd\u05ff\7,"+
"\2\2\u05fe\u05fd\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff\u0600\3\2\2\2\u0600"+
"\u0601\5\u00c4c\2\u0601\u00c3\3\2\2\2\u0602\u0607\5\u00c6d\2\u0603\u0604"+
"\7\u0099\2\2\u0604\u0606\5\u00c6d\2\u0605\u0603\3\2\2\2\u0606\u0609\3"+
"\2\2\2\u0607\u0605\3\2\2\2\u0607\u0608\3\2\2\2\u0608\u00c5\3\2\2\2\u0609"+
"\u0607\3\2\2\2\u060a\u060e\7\u00a6\2\2\u060b\u060e\5\u00ccg\2\u060c\u060e"+
"\5\u00c8e\2\u060d\u060a\3\2\2\2\u060d\u060b\3\2\2\2\u060d\u060c\3\2\2"+
"\2\u060e\u00c7\3\2\2\2\u060f\u0611\5\u0122\u0092\2\u0610\u0612\5\u00ca"+
"f\2\u0611\u0610\3\2\2\2\u0611\u0612\3\2\2\2\u0612\u0617\3\2\2\2\u0613"+
"\u0615\7\20\2\2\u0614\u0613\3\2\2\2\u0614\u0615\3\2\2\2\u0615\u0616\3"+
"\2\2\2\u0616\u0618\5\u01c8\u00e5\2\u0617\u0614\3\2\2\2\u0617\u0618\3\2"+
"\2\2\u0618\u00c9\3\2\2\2\u0619\u061a\7\u00bd\2\2\u061a\u061b\7\u00c5\2"+
"\2\u061b\u00cb\3\2\2\2\u061c\u061d\7\u00c5\2\2\u061d\u061e\7\u00b7\2\2"+
"\u061e\u0621\7\u00a6\2\2\u061f\u0620\7\20\2\2\u0620\u0622\7\u00c5\2\2"+
"\u0621\u061f\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u00cd\3\2\2\2\u0623\u0628"+
"\5\u0184\u00c3\2\u0624\u0628\5\u00d2j\2\u0625\u0628\5\u00d4k\2\u0626\u0628"+
"\5\u00d6l\2\u0627\u0623\3\2\2\2\u0627\u0624\3\2\2\2\u0627\u0625\3\2\2"+
"\2\u0627\u0626\3\2\2\2\u0628\u062a\3\2\2\2\u0629\u062b\5\u00d8m\2\u062a"+
"\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b\u062f\3\2\2\2\u062c\u062d\7\20"+
"\2\2\u062d\u0630\7\u00c5\2\2\u062e\u0630\7\u00c5\2\2\u062f\u062c\3\2\2"+
"\2\u062f\u062e\3\2\2\2\u062f\u0630\3\2\2\2\u0630\u0632\3\2\2\2\u0631\u0633"+
"\7>\2\2\u0632\u0631\3\2\2\2\u0632\u0633\3\2\2\2\u0633\u0636\3\2\2\2\u0634"+
"\u0637\7?\2\2\u0635\u0637\7@\2\2\u0636\u0634\3\2\2\2\u0636\u0635\3\2\2"+
"\2\u0636\u0637\3\2\2\2\u0637\u00cf\3\2\2\2\u0638\u0639\7z\2\2\u0639\u063f"+
"\7\u00c5\2\2\u063a\u063c\7\u0092\2\2\u063b\u063d\5\u01a8\u00d5\2\u063c"+
"\u063b\3\2\2\2\u063c\u063d\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640\7\u0093"+
"\2\2\u063f\u063a\3\2\2\2\u063f\u0640\3\2\2\2\u0640\u00d1\3\2\2\2\u0641"+
"\u0645\7A\2\2\u0642\u0644\5\24\13\2\u0643\u0642\3\2\2\2\u0644\u0647\3"+
"\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0648\3\2\2\2\u0647"+
"\u0645\3\2\2\2\u0648\u0649\7\u0094\2\2\u0649\u064a\5\u0166\u00b4\2\u064a"+
"\u064b\7\u0095\2\2\u064b\u00d3\3\2\2\2\u064c\u064d\7B\2\2\u064d\u064e"+
"\7\u0098\2\2\u064e\u064f\7\u00c5\2\2\u064f\u0652\7\u0094\2\2\u0650\u0653"+
"\7\u00c4\2\2\u0651\u0653\7\u00c3\2\2\u0652\u0650\3\2\2\2\u0652\u0651\3"+
"\2\2\2\u0653\u0659\3\2\2\2\u0654\u0657\7C\2\2\u0655\u0658\7\u00c4\2\2"+
"\u0656\u0658\7\u00c3\2\2\u0657\u0655\3\2\2\2\u0657\u0656\3\2\2\2\u0658"+
"\u065a\3\2\2\2\u0659\u0654\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u065b\3\2"+
"\2\2\u065b\u065c\7\u0095\2\2\u065c\u00d5\3\2\2\2\u065d\u065e\7\u00c5\2"+
"\2\u065e\u065f\7\u0098\2\2\u065f\u0665\5\u0198\u00cd\2\u0660\u0662\7\u0092"+
"\2\2\u0661\u0663\5\u01a8\u00d5\2\u0662\u0661\3\2\2\2\u0662\u0663\3\2\2"+
"\2\u0663\u0664\3\2\2\2\u0664\u0666\7\u0093\2\2\u0665\u0660\3\2\2\2\u0665"+
"\u0666\3\2\2\2\u0666\u0668\3\2\2\2\u0667\u0669\5\u0192\u00ca\2\u0668\u0667"+
"\3\2\2\2\u0668\u0669\3\2\2\2\u0669\u00d7\3\2\2\2\u066a\u066b\7\u00b7\2"+
"\2\u066b\u0670\5\u00dan\2\u066c\u066d\7\u00b7\2\2\u066d\u066f\5\u00da"+
"n\2\u066e\u066c\3\2\2\2\u066f\u0672\3\2\2\2\u0670\u066e\3\2\2\2\u0670"+
"\u0671\3\2\2\2\u0671\u067d\3\2\2\2\u0672\u0670\3\2\2\2\u0673\u0674\7\u00be"+
"\2\2\u0674\u0679\5\u00dco\2\u0675\u0676\7\u00be\2\2\u0676\u0678\5\u00dc"+
"o\2\u0677\u0675\3\2\2\2\u0678\u067b\3\2\2\2\u0679\u0677\3\2\2\2\u0679"+
"\u067a\3\2\2\2\u067a\u067d\3\2\2\2\u067b\u0679\3\2\2\2\u067c\u066a\3\2"+
"\2\2\u067c\u0673\3\2\2\2\u067d\u00d9\3\2\2\2\u067e\u067f\7\u00c5\2\2\u067f"+
"\u0680\7\u0098\2\2\u0680\u0681\5\u00dep\2\u0681\u00db\3\2\2\2\u0682\u0683"+
"\7\u00c5\2\2\u0683\u0685\7\u0098\2\2\u0684\u0682\3\2\2\2\u0684\u0685\3"+
"\2\2\2\u0685\u0686\3\2\2\2\u0686\u0687\5\u00dep\2\u0687\u00dd\3\2\2\2"+
"\u0688\u068b\7\u00c5\2\2\u0689\u068b\7}\2\2\u068a\u0688\3\2\2\2\u068a"+
"\u0689\3\2\2\2\u068b\u0691\3\2\2\2\u068c\u068e\7\u0092\2\2\u068d\u068f"+
"\5\u01aa\u00d6\2\u068e\u068d\3\2\2\2\u068e\u068f\3\2\2\2\u068f\u0690\3"+
"\2\2\2\u0690\u0692\7\u0093\2\2\u0691\u068c\3\2\2\2\u0691\u0692\3\2\2\2"+
"\u0692\u00df\3\2\2\2\u0693\u0698\5\u00e2r\2\u0694\u0695\7\u0099\2\2\u0695"+
"\u0697\5\u00e2r\2\u0696\u0694\3\2\2\2\u0697\u069a\3\2\2\2\u0698\u0696"+
"\3\2\2\2\u0698\u0699\3\2\2\2\u0699\u00e1\3\2\2\2\u069a\u0698\3\2\2\2\u069b"+
"\u069f\5\u0122\u0092\2\u069c\u069f\5\u00e4s\2\u069d\u069f\5\u00e6t\2\u069e"+
"\u069b\3\2\2\2\u069e\u069c\3\2\2\2\u069e\u069d\3\2\2\2\u069f\u00e3\3\2"+
"\2\2\u06a0\u06a1\t\5\2\2\u06a1\u06a2\7\u0092\2\2\u06a2\u06a7\5\u00eav"+
"\2\u06a3\u06a4\7\u0099\2\2\u06a4\u06a6\5\u00eav\2\u06a5\u06a3\3\2\2\2"+
"\u06a6\u06a9\3\2\2\2\u06a7\u06a5\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8\u06aa"+
"\3\2\2\2\u06a9\u06a7\3\2\2\2\u06aa\u06ab\7\u0093\2\2\u06ab\u00e5\3\2\2"+
"\2\u06ac\u06ad\7\u0088\2\2\u06ad\u06ae\7\u008a\2\2\u06ae\u06af\7\u0092"+
"\2\2\u06af\u06b4\5\u00e8u\2\u06b0\u06b1\7\u0099\2\2\u06b1\u06b3\5\u00e8"+
"u\2\u06b2\u06b0\3\2\2\2\u06b3\u06b6\3\2\2\2\u06b4\u06b2\3\2\2\2\u06b4"+
"\u06b5\3\2\2\2\u06b5\u06b7\3\2\2\2\u06b6\u06b4\3\2\2\2\u06b7\u06b8\7\u0093"+
"\2\2\u06b8\u00e7\3\2\2\2\u06b9\u06bc\5\u00e4s\2\u06ba\u06bc\5\u00eav\2"+
"\u06bb\u06b9\3\2\2\2\u06bb\u06ba\3\2\2\2\u06bc\u00e9\3\2\2\2\u06bd\u06cb"+
"\5\u0122\u0092\2\u06be\u06c7\7\u0092\2\2\u06bf\u06c4\5\u0122\u0092\2\u06c0"+
"\u06c1\7\u0099\2\2\u06c1\u06c3\5\u0122\u0092\2\u06c2\u06c0\3\2\2\2\u06c3"+
"\u06c6\3\2\2\2\u06c4\u06c2\3\2\2\2\u06c4\u06c5\3\2\2\2\u06c5\u06c8\3\2"+
"\2\2\u06c6\u06c4\3\2\2\2\u06c7\u06bf\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8"+
"\u06c9\3\2\2\2\u06c9\u06cb\7\u0093\2\2\u06ca\u06bd\3\2\2\2\u06ca\u06be"+
"\3\2\2\2\u06cb\u00eb\3\2\2\2\u06cc\u06d1\5\u00eex\2\u06cd\u06ce\7\u0099"+
"\2\2\u06ce\u06d0\5\u00eex\2\u06cf\u06cd\3\2\2\2\u06d0\u06d3\3\2\2\2\u06d1"+
"\u06cf\3\2\2\2\u06d1\u06d2\3\2\2\2\u06d2\u00ed\3\2\2\2\u06d3\u06d1\3\2"+
"\2\2\u06d4\u06d7\5\u0122\u0092\2\u06d5\u06d8\78\2\2\u06d6\u06d8\79\2\2"+
"\u06d7\u06d5\3\2\2\2\u06d7\u06d6\3\2\2\2\u06d7\u06d8\3\2\2\2\u06d8\u00ef"+
"\3\2\2\2\u06d9\u06da\5\u0126\u0094\2\u06da\u00f1\3\2\2\2\u06db\u06dd\5"+
"\u00f6|\2\u06dc\u06db\3\2\2\2\u06dc\u06dd\3\2\2\2\u06dd\u06e2\3\2\2\2"+
"\u06de\u06e3\7-\2\2\u06df\u06e3\7\62\2\2\u06e0\u06e3\7\63\2\2\u06e1\u06e3"+
"\7Q\2\2\u06e2\u06de\3\2\2\2\u06e2\u06df\3\2\2\2\u06e2\u06e0\3\2\2\2\u06e2"+
"\u06e1\3\2\2\2\u06e2\u06e3\3\2\2\2\u06e3\u0700\3\2\2\2\u06e4\u06eb\7\r"+
"\2\2\u06e5\u06ec\5\u01ce\u00e8\2\u06e6\u06e9\5\u01e2\u00f2\2\u06e7\u06e9"+
"\7\u00c5\2\2\u06e8\u06e6\3\2\2\2\u06e8\u06e7\3\2\2\2\u06e9\u06ea\3\2\2"+
"\2\u06ea\u06ec\7\61\2\2\u06eb\u06e5\3\2\2\2\u06eb\u06e8\3\2\2\2\u06ec"+
"\u0701\3\2\2\2\u06ed\u06ee\7V\2\2\u06ee\u0701\5\u00fa~\2\u06ef\u06f0\7"+
"\35\2\2\u06f0\u06f3\5\u0122\u0092\2\u06f1\u06f2\7\36\2\2\u06f2\u06f4\5"+
"F$\2\u06f3\u06f1\3\2\2\2\u06f3\u06f4\3\2\2\2\u06f4\u0701\3\2\2\2\u06f5"+
"\u06f6\7\35\2\2\u06f6\u06f9\7\u0084\2\2\u06f7\u06f8\7\13\2\2\u06f8\u06fa"+
"\5\u0122\u0092\2\u06f9\u06f7\3\2\2\2\u06f9\u06fa\3\2\2\2\u06fa\u06fd\3"+
"\2\2\2\u06fb\u06fc\7\36\2\2\u06fc\u06fe\5F$\2\u06fd\u06fb\3\2\2\2\u06fd"+
"\u06fe\3\2\2\2\u06fe\u0701\3\2\2\2\u06ff\u0701\3\2\2\2\u0700\u06e4\3\2"+
"\2\2\u0700\u06ed\3\2\2\2\u0700\u06ef\3\2\2\2\u0700\u06f5\3\2\2\2\u0700"+
"\u06ff\3\2\2\2\u0701\u0703\3\2\2\2\u0702\u0704\5\u00f4{\2\u0703\u0702"+
"\3\2\2\2\u0703\u0704\3\2\2\2\u0704\u00f3\3\2\2\2\u0705\u0706\7\13\2\2"+
"\u0706\u0707\7\35\2\2\u0707\u070a\7\u0084\2\2\u0708\u0709\7\13\2\2\u0709"+
"\u070b\5\u0122\u0092\2\u070a\u0708\3\2\2\2\u070a\u070b\3\2\2\2\u070b\u070e"+
"\3\2\2\2\u070c\u070d\7\36\2\2\u070d\u070f\5F$\2\u070e\u070c\3\2\2\2\u070e"+
"\u070f\3\2\2\2\u070f\u00f5\3\2\2\2\u0710\u0715\7y\2\2\u0711\u0716\5\u01ce"+
"\u00e8\2\u0712\u0713\5\u01e2\u00f2\2\u0713\u0714\7\61\2\2\u0714\u0716"+
"\3\2\2\2\u0715\u0711\3\2\2\2\u0715\u0712\3\2\2\2\u0716\u00f7\3\2\2\2\u0717"+
"\u071a\5\u01e8\u00f5\2\u0718\u071a\7\u00c5\2\2\u0719\u0717\3\2\2\2\u0719"+
"\u0718\3\2\2\2\u071a\u0723\3\2\2\2\u071b\u071e\7\u0099\2\2\u071c\u071e"+
"\7q\2\2\u071d\u071b\3\2\2\2\u071d\u071c\3\2\2\2\u071e\u0721\3\2\2\2\u071f"+
"\u0722\5\u01e8\u00f5\2\u0720\u0722\7\u00c5\2\2\u0721\u071f\3\2\2\2\u0721"+
"\u0720\3\2\2\2\u0722\u0724\3\2\2\2\u0723\u071d\3\2\2\2\u0723\u0724\3\2"+
"\2\2\u0724\u00f9\3\2\2\2\u0725\u0726\7\u0092\2\2\u0726\u0727\5\u01aa\u00d6"+
"\2\u0727\u0728\7\u0093\2\2\u0728\u00fb\3\2\2\2\u0729\u072a\7\35\2\2\u072a"+
"\u072b\5\u0122\u0092\2\u072b\u072c\7\36\2\2\u072c\u072d\5\u0122\u0092"+
"\2\u072d\u00fd\3\2\2\2\u072e\u072f\7\34\2\2\u072f\u0730\5\u0122\u0092"+
"\2\u0730\u00ff\3\2\2\2\u0731\u0732\7s\2\2\u0732\u0734\7\u0092\2\2\u0733"+
"\u0735\5\u0102\u0082\2\u0734\u0733\3\2\2\2\u0734\u0735\3\2\2\2\u0735\u0736"+
"\3\2\2\2\u0736\u0738\5\u0104\u0083\2\u0737\u0739\5\u0108\u0085\2\u0738"+
"\u0737\3\2\2\2\u0738\u0739\3\2\2\2\u0739\u073b\3\2\2\2\u073a\u073c\5\u010c"+
"\u0087\2\u073b\u073a\3\2\2\2\u073b\u073c\3\2\2\2\u073c\u073d\3\2\2\2\u073d"+
"\u073f\5\u010a\u0086\2\u073e\u0740\5\u010e\u0088\2\u073f\u073e\3\2\2\2"+
"\u073f\u0740\3\2\2\2\u0740\u0742\3\2\2\2\u0741\u0743\5\u011e\u0090\2\u0742"+
"\u0741\3\2\2\2\u0742\u0743\3\2\2\2\u0743\u0744\3\2\2\2\u0744\u0745\7\u0093"+
"\2\2\u0745\u0101\3\2\2\2\u0746\u0747\7w\2\2\u0747\u0748\7)\2\2\u0748\u074d"+
"\5\u0122\u0092\2\u0749\u074a\7\u0099\2\2\u074a\u074c\5\u0122\u0092\2\u074b"+
"\u0749\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074d\u074e\3\2"+
"\2\2\u074e\u0103\3\2\2\2\u074f\u074d\3\2\2\2\u0750\u0751\7u\2\2\u0751"+
"\u0756\5\u0106\u0084\2\u0752\u0753\7\u0099\2\2\u0753\u0755\5\u0106\u0084"+
"\2\u0754\u0752\3\2\2\2\u0755\u0758\3\2\2\2\u0756\u0754\3\2\2\2\u0756\u0757"+
"\3\2\2\2\u0757\u0105\3\2\2\2\u0758\u0756\3\2\2\2\u0759\u075e\5\u0122\u0092"+
"\2\u075a\u075c\7\20\2\2\u075b\u075d\7\u00c5\2\2\u075c\u075b\3\2\2\2\u075c"+
"\u075d\3\2\2\2\u075d\u075f\3\2\2\2\u075e\u075a\3\2\2\2\u075e\u075f\3\2"+
"\2\2\u075f\u0107\3\2\2\2\u0760\u0761\7-\2\2\u0761\u0762\7x\2\2\u0762\u0109"+
"\3\2\2\2\u0763\u0764\7A\2\2\u0764\u0765\7\u0092\2\2\u0765\u0766\5\u0110"+
"\u0089\2\u0766\u0767\7\u0093\2\2\u0767\u010b\3\2\2\2\u0768\u0769\7y\2"+
"\2\u0769\u076a\5\u01c8\u00e5\2\u076a\u076b\5\u01c8\u00e5\2\u076b\u076c"+
"\5\u01c8\u00e5\2\u076c\u076d\5\u01c8\u00e5\2\u076d\u076e\5\u01c8\u00e5"+
"\2\u076e\u010d\3\2\2\2\u076f\u0770\7\u00c5\2\2\u0770\u0773\5\u01ce\u00e8"+
"\2\u0771\u0772\7\n\2\2\u0772\u0774\7\u0084\2\2\u0773\u0771\3\2\2\2\u0773"+
"\u0774\3\2\2\2\u0774\u010f\3\2\2\2\u0775\u077a\5\u0112\u008a\2\u0776\u0777"+
"\7\u00b0\2\2\u0777\u0779\5\u0112\u008a\2\u0778\u0776\3\2\2\2\u0779\u077c"+
"\3\2\2\2\u077a\u0778\3\2\2\2\u077a\u077b\3\2\2\2\u077b\u0111\3\2\2\2\u077c"+
"\u077a\3\2\2\2\u077d\u077f\5\u0114\u008b\2\u077e\u077d\3\2\2\2\u077f\u0780"+
"\3\2\2\2\u0780\u077e\3\2\2\2\u0780\u0781\3\2\2\2\u0781\u0113\3\2\2\2\u0782"+
"\u0786\5\u0118\u008d\2\u0783\u0786\5\u0116\u008c\2\u0784\u0786\5\u011a"+
"\u008e\2\u0785\u0782\3\2\2\2\u0785\u0783\3\2\2\2\u0785\u0784\3\2\2\2\u0786"+
"\u0115\3\2\2\2\u0787\u0788\7\u0092\2\2\u0788\u0789\5\u0110\u0089\2\u0789"+
"\u078d\7\u0093\2\2\u078a\u078e\7\u00a6\2\2\u078b\u078e\7\u00a0\2\2\u078c"+
"\u078e\7\u0091\2\2\u078d\u078a\3\2\2\2\u078d\u078b\3\2\2\2\u078d\u078c"+
"\3\2\2\2\u078d\u078e\3\2\2\2\u078e\u0790\3\2\2\2\u078f\u0791\5\u011c\u008f"+
"\2\u0790\u078f\3\2\2\2\u0790\u0791\3\2\2\2\u0791\u0117\3\2\2\2\u0792\u0793"+
"\7t\2\2\u0793\u0794\7\u0092\2\2\u0794\u0799\5\u0110\u0089\2\u0795\u0796"+
"\7\u0099\2\2\u0796\u0798\5\u0110\u0089\2\u0797\u0795\3\2\2\2\u0798\u079b"+
"\3\2\2\2\u0799\u0797\3\2\2\2\u0799\u079a\3\2\2\2\u079a\u079c\3\2\2\2\u079b"+
"\u0799\3\2\2\2\u079c\u079d\7\u0093\2\2\u079d\u0119\3\2\2\2\u079e\u07a7"+
"\7\u00c5\2\2\u079f\u07a3\7\u00a6\2\2\u07a0\u07a3\7\u00a0\2\2\u07a1\u07a3"+
"\7\u0091\2\2\u07a2\u079f\3\2\2\2\u07a2\u07a0\3\2\2\2\u07a2\u07a1\3\2\2"+
"\2\u07a3\u07a5\3\2\2\2\u07a4\u07a6\7\u0091\2\2\u07a5\u07a4\3\2\2\2\u07a5"+
"\u07a6\3\2\2\2\u07a6\u07a8\3\2\2\2\u07a7\u07a2\3\2\2\2\u07a7\u07a8\3\2"+
"\2\2\u07a8\u07aa\3\2\2\2\u07a9\u07ab\5\u011c\u008f\2\u07aa\u07a9\3\2\2"+
"\2\u07aa\u07ab\3\2\2\2\u07ab\u011b\3\2\2\2\u07ac\u07ae\7\u0096\2\2\u07ad"+
"\u07af\5\u0122\u0092\2\u07ae\u07ad\3\2\2\2\u07ae\u07af\3\2\2\2\u07af\u07b1"+
"\3\2\2\2\u07b0\u07b2\7\u0099\2\2\u07b1\u07b0\3\2\2\2\u07b1\u07b2\3\2\2"+
"\2\u07b2\u07b4\3\2\2\2\u07b3\u07b5\5\u0122\u0092\2\u07b4\u07b3\3\2\2\2"+
"\u07b4\u07b5\3\2\2\2\u07b5\u07b6\3\2\2\2\u07b6\u07b7\7\u0097\2\2\u07b7"+
"\u011d\3\2\2\2\u07b8\u07b9\7v\2\2\u07b9\u07be\5\u0120\u0091\2\u07ba\u07bb"+
"\7\u0099\2\2\u07bb\u07bd\5\u0120\u0091\2\u07bc\u07ba\3\2\2\2\u07bd\u07c0"+
"\3\2\2\2\u07be\u07bc\3\2\2\2\u07be\u07bf\3\2\2\2\u07bf\u011f\3\2\2\2\u07c0"+
"\u07be\3\2\2\2\u07c1\u07c2\7\u00c5\2\2\u07c2\u07c3\7\20\2\2\u07c3\u07c4"+
"\5\u0122\u0092\2\u07c4\u0121\3\2\2\2\u07c5\u07c6\5\u0124\u0093\2\u07c6"+
"\u0123\3\2\2\2\u07c7\u07c8\b\u0093\1\2\u07c8\u07ca\7\33\2\2\u07c9\u07cb"+
"\5\u00fc\177\2\u07ca\u07c9\3\2\2\2\u07cb\u07cc\3\2\2\2\u07cc\u07ca\3\2"+
"\2\2\u07cc\u07cd\3\2\2\2\u07cd\u07cf\3\2\2\2\u07ce\u07d0\5\u00fe\u0080"+
"\2\u07cf\u07ce\3\2\2\2\u07cf\u07d0\3\2\2\2\u07d0\u07d1\3\2\2\2\u07d1\u07d2"+
"\7\37\2\2\u07d2\u07d3\b\u0093\1\2\u07d3\u07e4\3\2\2\2\u07d4\u07d5\b\u0093"+
"\1\2\u07d5\u07d6\7\33\2\2\u07d6\u07d8\5\u0122\u0092\2\u07d7\u07d9\5\u00fc"+
"\177\2\u07d8\u07d7\3\2\2\2\u07d9\u07da\3\2\2\2\u07da\u07d8\3\2\2\2\u07da"+
"\u07db\3\2\2\2\u07db\u07dd\3\2\2\2\u07dc\u07de\5\u00fe\u0080\2\u07dd\u07dc"+
"\3\2\2\2\u07dd\u07de\3\2\2\2\u07de\u07df\3\2\2\2\u07df\u07e0\7\37\2\2"+
"\u07e0\u07e1\b\u0093\1\2\u07e1\u07e4\3\2\2\2\u07e2\u07e4\5\u0126\u0094"+
"\2\u07e3\u07c7\3\2\2\2\u07e3\u07d4\3\2\2\2\u07e3\u07e2\3\2\2\2\u07e4\u0125"+
"\3\2\2\2\u07e5\u07ea\5\u0128\u0095\2\u07e6\u07e7\7\n\2\2\u07e7\u07e9\5"+
"\u0128\u0095\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\u0127\3\2\2\2\u07ec\u07ea\3\2\2\2\u07ed"+
"\u07f2\5\u012a\u0096\2\u07ee\u07ef\7\13\2\2\u07ef\u07f1\5\u012a\u0096"+
"\2\u07f0\u07ee\3\2\2\2\u07f1\u07f4\3\2\2\2\u07f2\u07f0\3\2\2\2\u07f2\u07f3"+
"\3\2\2\2\u07f3\u0129\3\2\2\2\u07f4\u07f2\3\2\2\2\u07f5\u07fa\5\u012c\u0097"+
"\2\u07f6\u07f7\t\6\2\2\u07f7\u07f9\5\u012c\u0097\2\u07f8\u07f6\3\2\2\2"+
"\u07f9\u07fc\3\2\2\2\u07fa\u07f8\3\2\2\2\u07fa\u07fb\3\2\2\2\u07fb\u012b"+
"\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fd\u0801\5\u012e\u0098\2\u07fe\u07ff\7"+
"\f\2\2\u07ff\u0801\5\u012e\u0098\2\u0800\u07fd\3\2\2\2\u0800\u07fe\3\2"+
"\2\2\u0801\u012d\3\2\2\2\u0802\u081d\5\u0130\u0099\2\u0803\u080a\7\u008f"+
"\2\2\u0804\u080a\7(\2\2\u0805\u0806\7(\2\2\u0806\u080a\7\f\2\2\u0807\u080a"+
"\7\u0090\2\2\u0808\u080a\7\u009d\2\2\u0809\u0803\3\2\2\2\u0809\u0804\3"+
"\2\2\2\u0809\u0805\3\2\2\2\u0809\u0807\3\2\2\2\u0809\u0808\3\2\2\2\u080a"+
"\u0819\3\2\2\2\u080b\u081a\5\u0130\u0099\2\u080c\u0810\7.\2\2\u080d\u0810"+
"\7/\2\2\u080e\u0810\7-\2\2\u080f\u080c\3\2\2\2\u080f\u080d\3\2\2\2\u080f"+
"\u080e\3\2\2\2\u0810\u0817\3\2\2\2\u0811\u0813\7\u0092\2\2\u0812\u0814"+
"\5\u01a8\u00d5\2\u0813\u0812\3\2\2\2\u0813\u0814\3\2\2\2\u0814\u0815\3"+
"\2\2\2\u0815\u0818\7\u0093\2\2\u0816\u0818\5\u0144\u00a3\2\u0817\u0811"+
"\3\2\2\2\u0817\u0816\3\2\2\2\u0818\u081a\3\2\2\2\u0819\u080b\3\2\2\2\u0819"+
"\u080f\3\2\2\2\u081a\u081c\3\2\2\2\u081b\u0809\3\2\2\2\u081c\u081f\3\2"+
"\2\2\u081d\u081b\3\2\2\2\u081d\u081e\3\2\2\2\u081e\u012f\3\2\2\2\u081f"+
"\u081d\3\2\2\2\u0820\u0862\5\u0134\u009b\2\u0821\u0826\7\u00ad\2\2\u0822"+
"\u0826\7\u00ab\2\2\u0823\u0826\7\u00ac\2\2\u0824\u0826\7\u00aa\2\2\u0825"+
"\u0821\3\2\2\2\u0825\u0822\3\2\2\2\u0825\u0823\3\2\2\2\u0825\u0824\3\2"+
"\2\2\u0826\u0835\3\2\2\2\u0827\u0836\5\u0134\u009b\2\u0828\u082c\7.\2"+
"\2\u0829\u082c\7/\2\2\u082a\u082c\7-\2\2\u082b\u0828\3\2\2\2\u082b\u0829"+
"\3\2\2\2\u082b\u082a\3\2\2\2\u082c\u0833\3\2\2\2\u082d\u082f\7\u0092\2"+
"\2\u082e\u0830\5\u01a8\u00d5\2\u082f\u082e\3\2\2\2\u082f\u0830\3\2\2\2"+
"\u0830\u0831\3\2\2\2\u0831\u0834\7\u0093\2\2\u0832\u0834\5\u0144\u00a3"+
"\2\u0833\u082d\3\2\2\2\u0833\u0832\3\2\2\2\u0834\u0836\3\2\2\2\u0835\u0827"+
"\3\2\2\2\u0835\u082b\3\2\2\2\u0836\u0838\3\2\2\2\u0837\u0825\3\2\2\2\u0838"+
"\u083b\3\2\2\2\u0839\u0837\3\2\2\2\u0839\u083a\3\2\2\2\u083a\u0863\3\2"+
"\2\2\u083b\u0839\3\2\2\2\u083c\u083e\7\f\2\2\u083d\u083c\3\2\2\2\u083d"+
"\u083e\3\2\2\2\u083e\u0860\3\2\2\2\u083f\u0842\7\5\2\2\u0840\u0843\7\u0092"+
"\2\2\u0841\u0843\7\u0094\2\2\u0842\u0840\3\2\2\2\u0842\u0841\3\2\2\2\u0843"+
"\u0844\3\2\2\2\u0844\u084e\5\u0122\u0092\2\u0845\u0846\7\u0098\2\2\u0846"+
"\u084f\5\u0122\u0092\2\u0847\u0848\7\u0099\2\2\u0848\u084a\5\u0122\u0092"+
"\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\u084f\3\2\2\2\u084d\u084b\3\2\2\2\u084e\u0845\3\2\2\2\u084e"+
"\u084b\3\2\2\2\u084f\u0852\3\2\2\2\u0850\u0853\7\u0093\2\2\u0851\u0853"+
"\7\u0095\2\2\u0852\u0850\3\2\2\2\u0852\u0851\3\2\2\2\u0853\u0861\3\2\2"+
"\2\u0854\u0855\7\5\2\2\u0855\u0861\5\u0132\u009a\2\u0856\u0857\7\6\2\2"+
"\u0857\u0861\5\u0164\u00b3\2\u0858\u0859\7\7\2\2\u0859\u085c\5\u0134\u009b"+
"\2\u085a\u085b\7\t\2\2\u085b\u085d\5\u01ea\u00f6\2\u085c\u085a\3\2\2\2"+
"\u085c\u085d\3\2\2\2\u085d\u0861\3\2\2\2\u085e\u085f\7\b\2\2\u085f\u0861"+
"\5\u0134\u009b\2\u0860\u083f\3\2\2\2\u0860\u0854\3\2\2\2\u0860\u0856\3"+
"\2\2\2\u0860\u0858\3\2\2\2\u0860\u085e\3\2\2\2\u0861\u0863\3\2\2\2\u0862"+
"\u0839\3\2\2\2\u0862\u083d\3\2\2\2\u0863\u0131\3\2\2\2\u0864\u0865\5\u0148"+
"\u00a5\2\u0865\u0133\3\2\2\2\u0866\u0870\5\u0136\u009c\2\u0867\u0868\7"+
"\u00b2\2\2\u0868\u086d\5\u0136\u009c\2\u0869\u086a\7\u00b2\2\2\u086a\u086c"+
"\5\u0136\u009c\2\u086b\u0869\3\2\2\2\u086c\u086f\3\2\2\2\u086d\u086b\3"+
"\2\2\2\u086d\u086e\3\2\2\2\u086e\u0871\3\2\2\2\u086f\u086d\3\2\2\2\u0870"+
"\u0867\3\2\2\2\u0870\u0871\3\2\2\2\u0871\u0135\3\2\2\2\u0872\u0877\5\u0138"+
"\u009d\2\u0873\u0874\t\7\2\2\u0874\u0876\5\u0138\u009d\2\u0875\u0873\3"+
"\2\2\2\u0876\u0879\3\2\2\2\u0877\u0875\3\2\2\2\u0877\u0878\3\2\2\2\u0878"+
"\u0137\3\2\2\2\u0879\u0877\3\2\2\2\u087a\u087f\5\u013a\u009e\2\u087b\u087c"+
"\t\b\2\2\u087c\u087e\5\u013a\u009e\2\u087d\u087b\3\2\2\2\u087e\u0881\3"+
"\2\2\2\u087f\u087d\3\2\2\2\u087f\u0880\3\2\2\2\u0880\u0139\3\2\2\2\u0881"+
"\u087f\3\2\2\2\u0882\u0883\7\u00a3\2\2\u0883\u08be\5\u01c2\u00e2\2\u0884"+
"\u08be\5\u01e6\u00f4\2\u0885\u08be\5\u013c\u009f\2\u0886\u0887\7\u0092"+
"\2\2\u0887\u0888\5\u0122\u0092\2\u0888\u088a\7\u0093\2\2\u0889\u088b\5"+
"\u013e\u00a0\2\u088a\u0889\3\2\2\2\u088a\u088b\3\2\2\2\u088b\u08be\3\2"+
"\2\2\u088c\u08be\5\u014e\u00a8\2\u088d\u08be\5\u0152\u00aa\2\u088e\u08be"+
"\5\u014c\u00a7\2\u088f\u08be\5\u0142\u00a2\2\u0890\u08be\5\u0146\u00a4"+
"\2\u0891\u0892\7\u0080\2\2\u0892\u0893\7\u0096\2\2\u0893\u0898\5\u0140"+
"\u00a1\2\u0894\u0895\7\u0099\2\2\u0895\u0897\5\u0140\u00a1\2\u0896\u0894"+
"\3\2\2\2\u0897\u089a\3\2\2\2\u0898\u0896\3\2\2\2\u0898\u0899\3\2\2\2\u0899"+
"\u089b\3\2\2\2\u089a\u0898\3\2\2\2\u089b\u089c\7\u0097\2\2\u089c\u08be"+
"\3\2\2\2\u089d\u089e\7\u0080\2\2\u089e\u089f\5\u0198\u00cd\2\u089f\u08a8"+
"\7\u0092\2\2\u08a0\u08a5\5\u0122\u0092\2\u08a1\u08a2\7\u0099\2\2\u08a2"+
"\u08a4\5\u0122\u0092\2\u08a3\u08a1\3\2\2\2\u08a4\u08a7\3\2\2\2\u08a5\u08a3"+
"\3\2\2\2\u08a5\u08a6\3\2\2\2\u08a6\u08a9\3\2\2\2\u08a7\u08a5\3\2\2\2\u08a8"+
"\u08a0\3\2\2\2\u08a8\u08a9\3\2\2\2\u08a9\u08aa\3\2\2\2\u08aa\u08ac\7\u0093"+
"\2\2\u08ab\u08ad\5\u013e\u00a0\2\u08ac\u08ab\3\2\2\2\u08ac\u08ad\3\2\2"+
"\2\u08ad\u08be\3\2\2\2\u08ae\u08af\7\u00c5\2\2\u08af\u08b0\7\u0094\2\2"+
"\u08b0\u08b5\5\u0122\u0092\2\u08b1\u08b2\7\u0099\2\2\u08b2\u08b4\5\u0122"+
"\u0092\2\u08b3\u08b1\3\2\2\2\u08b4\u08b7\3\2\2\2\u08b5\u08b3\3\2\2\2\u08b5"+
"\u08b6\3\2\2\2\u08b6\u08b8\3\2\2\2\u08b7\u08b5\3\2\2\2\u08b8\u08ba\7\u0095"+
"\2\2\u08b9\u08bb\5\u013e\u00a0\2\u08ba\u08b9\3\2\2\2\u08ba\u08bb\3\2\2"+
"\2\u08bb\u08be\3\2\2\2\u08bc\u08be\5\u01ee\u00f8\2\u08bd\u0882\3\2\2\2"+
"\u08bd\u0884\3\2\2\2\u08bd\u0885\3\2\2\2\u08bd\u0886\3\2\2\2\u08bd\u088c"+
"\3\2\2\2\u08bd\u088d\3\2\2\2\u08bd\u088e\3\2\2\2\u08bd\u088f\3\2\2\2\u08bd"+
"\u0890\3\2\2\2\u08bd\u0891\3\2\2\2\u08bd\u089d\3\2\2\2\u08bd\u08ae\3\2"+
"\2\2\u08bd\u08bc\3\2\2\2\u08be\u013b\3\2\2\2\u08bf\u08c1\5\u01e4\u00f3"+
"\2\u08c0\u08c2\5\u013e\u00a0\2\u08c1\u08c0\3\2\2\2\u08c1\u08c2\3\2\2\2"+
"\u08c2\u013d\3\2\2\2\u08c3\u08c4\7\u00b7\2\2\u08c4\u08c9\5\u0158\u00ad"+
"\2\u08c5\u08c6\7\u00b7\2\2\u08c6\u08c8\5\u0158\u00ad\2\u08c7\u08c5\3\2"+
"\2\2\u08c8\u08cb\3\2\2\2\u08c9\u08c7\3\2\2\2\u08c9\u08ca\3\2\2\2\u08ca"+
"\u013f\3\2\2\2\u08cb\u08c9\3\2\2\2\u08cc\u08cf\5\u01c2\u00e2\2\u08cd\u08ce"+
"\7\u008f\2\2\u08ce\u08d0\5\u0122\u0092\2\u08cf\u08cd\3\2\2\2\u08cf\u08d0"+
"\3\2\2\2\u08d0\u0141\3\2\2\2\u08d1\u08d3\5\u0148\u00a5\2\u08d2\u08d4\5"+
"\u013e\u00a0\2\u08d3\u08d2\3\2\2\2\u08d3\u08d4\3\2\2";
private static final String _serializedATNSegment1 =
"\2\u08d4\u0143\3\2\2\2\u08d5\u08d6\5\u0148\u00a5\2\u08d6\u0145\3\2\2\2"+
"\u08d7\u08d8\7I\2\2\u08d8\u08d9\5\u0148\u00a5\2\u08d9\u0147\3\2\2\2\u08da"+
"\u08db\7\u0092\2\2\u08db\u08dd\7\32\2\2\u08dc\u08de\7,\2\2\u08dd\u08dc"+
"\3\2\2\2\u08dd\u08de\3\2\2\2\u08de\u08df\3\2\2\2\u08df\u08e0\5\u00c4c"+
"\2\u08e0\u08e1\7 \2\2\u08e1\u08e4\5\u014a\u00a6\2\u08e2\u08e3\7\17\2\2"+
"\u08e3\u08e5\5\u00c0a\2\u08e4\u08e2\3\2\2\2\u08e4\u08e5\3\2\2\2\u08e5"+
"\u08e9\3\2\2\2\u08e6\u08e7\7*\2\2\u08e7\u08e8\7)\2\2\u08e8\u08ea\5\u00e0"+
"q\2\u08e9\u08e6\3\2\2\2\u08e9\u08ea\3\2\2\2\u08ea\u08ed\3\2\2\2\u08eb"+
"\u08ec\7+\2\2\u08ec\u08ee\5\u00f0y\2\u08ed\u08eb\3\2\2\2\u08ed\u08ee\3"+
"\2\2\2\u08ee\u08ef\3\2\2\2\u08ef\u08f0\7\u0093\2\2\u08f0\u0149\3\2\2\2"+
"\u08f1\u08f3\5\u0184\u00c3\2\u08f2\u08f4\5\u00d8m\2\u08f3\u08f2\3\2\2"+
"\2\u08f3\u08f4\3\2\2\2\u08f4\u08f8\3\2\2\2\u08f5\u08f6\7\20\2\2\u08f6"+
"\u08f9\7\u00c5\2\2\u08f7\u08f9\7\u00c5\2\2\u08f8\u08f5\3\2\2\2\u08f8\u08f7"+
"\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9\u08fc\3\2\2\2\u08fa\u08fd\7?\2\2\u08fb"+
"\u08fd\7@\2\2\u08fc\u08fa\3\2\2\2\u08fc\u08fb\3\2\2\2\u08fc\u08fd\3\2"+
"\2\2\u08fd\u014b\3\2\2\2\u08fe\u0907\7\u0096\2\2\u08ff\u0904\5\u0122\u0092"+
"\2\u0900\u0901\7\u0099\2\2\u0901\u0903\5\u0122\u0092\2\u0902\u0900\3\2"+
"\2\2\u0903\u0906\3\2\2\2\u0904\u0902\3\2\2\2\u0904\u0905\3\2\2\2\u0905"+
"\u0908\3\2\2\2\u0906\u0904\3\2\2\2\u0907\u08ff\3\2\2\2\u0907\u0908\3\2"+
"\2\2\u0908\u0909\3\2\2\2\u0909\u090b\7\u0097\2\2\u090a\u090c\5\u013e\u00a0"+
"\2\u090b\u090a\3\2\2\2\u090b\u090c\3\2\2\2\u090c\u014d\3\2\2\2\u090d\u090e"+
"\7\21\2\2\u090e\u0910\7\u0092\2\2\u090f\u0911\t\t\2\2\u0910\u090f\3\2"+
"\2\2\u0910\u0911\3\2\2\2\u0911\u0912\3\2\2\2\u0912\u0913\5\u019c\u00cf"+
"\2\u0913\u0914\7\u0093\2\2\u0914\u09b1\3\2\2\2\u0915\u0916\7\22\2\2\u0916"+
"\u0918\7\u0092\2\2\u0917\u0919\t\t\2\2\u0918\u0917\3\2\2\2\u0918\u0919"+
"\3\2\2\2\u0919\u091a\3\2\2\2\u091a\u091b\5\u019c\u00cf\2\u091b\u091c\7"+
"\u0093\2\2\u091c\u09b1\3\2\2\2\u091d\u091e\7\31\2\2\u091e\u0921\7\u0092"+
"\2\2\u091f\u0922\7-\2\2\u0920\u0922\7,\2\2\u0921\u091f\3\2\2\2\u0921\u0920"+
"\3\2\2\2\u0921\u0922\3\2\2\2\u0922\u0923\3\2\2\2\u0923\u0924\5\u019c\u00cf"+
"\2\u0924\u0925\7\u0093\2\2\u0925\u09b1\3\2\2\2\u0926\u0927\7\26\2\2\u0927"+
"\u0929\7\u0092\2\2\u0928\u092a\t\t\2\2\u0929\u0928\3\2\2\2\u0929\u092a"+
"\3\2\2\2\u092a\u092b\3\2\2\2\u092b\u092c\5\u019c\u00cf\2\u092c\u092d\7"+
"\u0093\2\2\u092d\u09b1\3\2\2\2\u092e\u092f\7\27\2\2\u092f\u0931\7\u0092"+
"\2\2\u0930\u0932\t\t\2\2\u0931\u0930\3\2\2\2\u0931\u0932\3\2\2\2\u0932"+
"\u0933\3\2\2\2\u0933\u0934\5\u019c\u00cf\2\u0934\u0935\7\u0093\2\2\u0935"+
"\u09b1\3\2\2\2\u0936\u0937\7\30\2\2\u0937\u0939\7\u0092\2\2\u0938\u093a"+
"\t\t\2\2\u0939\u0938\3\2\2\2\u0939\u093a\3\2\2\2\u093a\u093b\3\2\2\2\u093b"+
"\u093c\5\u019c\u00cf\2\u093c\u093d\7\u0093\2\2\u093d\u09b1\3\2\2\2\u093e"+
"\u09b1\5\u0150\u00a9\2\u093f\u0940\7\25\2\2\u0940\u0941\7\u0092\2\2\u0941"+
"\u0942\5\u0122\u0092\2\u0942\u0943\7\u0099\2\2\u0943\u0948\5\u0122\u0092"+
"\2\u0944\u0945\7\u0099\2\2\u0945\u0947\5\u0122\u0092\2\u0946\u0944\3\2"+
"\2\2\u0947\u094a\3\2\2\2\u0948\u0946\3\2\2\2\u0948\u0949\3\2\2\2\u0949"+
"\u094b\3\2\2\2\u094a\u0948\3\2\2\2\u094b\u094c\7\u0093\2\2\u094c\u09b1"+
"\3\2\2\2\u094d\u094e\7D\2\2\u094e\u094f\7\u0092\2\2\u094f\u0952\5\u0122"+
"\u0092\2\u0950\u0951\7\u0099\2\2\u0951\u0953\5\u0122\u0092\2\u0952\u0950"+
"\3\2\2\2\u0952\u0953\3\2\2\2\u0953\u0954\3\2\2\2\u0954\u0956\7\u0093\2"+
"\2\u0955\u0957\5\u013e\u00a0\2\u0956\u0955\3\2\2\2\u0956\u0957\3\2\2\2"+
"\u0957\u09b1\3\2\2\2\u0958\u0959\7E\2\2\u0959\u095a\7\u0092\2\2\u095a"+
"\u095d\5\u0122\u0092\2\u095b\u095c\7\u0099\2\2\u095c\u095e\5\u0122\u0092"+
"\2\u095d\u095b\3\2\2\2\u095d\u095e\3\2\2\2\u095e\u095f\3\2\2\2\u095f\u0961"+
"\7\u0093\2\2\u0960\u0962\5\u013e\u00a0\2\u0961\u0960\3\2\2\2\u0961\u0962"+
"\3\2\2\2\u0962\u09b1\3\2\2\2\u0963\u0964\7F\2\2\u0964\u0965\7\u0092\2"+
"\2\u0965\u0966\5\u0122\u0092\2\u0966\u0967\7\u0093\2\2\u0967\u09b1\3\2"+
"\2\2\u0968\u0969\7G\2\2\u0969\u096a\7\u0092\2\2\u096a\u096b\5\u0122\u0092"+
"\2\u096b\u096d\7\u0093\2\2\u096c\u096e\5\u013e\u00a0\2\u096d\u096c\3\2"+
"\2\2\u096d\u096e\3\2\2\2\u096e\u09b1\3\2\2\2\u096f\u0970\7H\2\2\u0970"+
"\u0971\7\u0092\2\2\u0971\u0972\5\u0122\u0092\2\u0972\u0973\7\u0099\2\2"+
"\u0973\u0974\5\u01c2\u00e2\2\u0974\u0975\7\u0093\2\2\u0975\u09b1\3\2\2"+
"\2\u0976\u0977\7\u0088\2\2\u0977\u0978\7\u0092\2\2\u0978\u0979\5\u0122"+
"\u0092\2\u0979\u097a\7\u0093\2\2\u097a\u09b1\3\2\2\2\u097b\u097c\7\u0089"+
"\2\2\u097c\u097d\7\u0092\2\2\u097d\u097e\5\u01a8\u00d5\2\u097e\u097f\7"+
"\u0093\2\2\u097f\u09b1\3\2\2\2\u0980\u0981\7L\2\2\u0981\u0982\7\u0092"+
"\2\2\u0982\u0983\5\u0122\u0092\2\u0983\u0984\7\u0099\2\2\u0984\u0989\5"+
"\u0198\u00cd\2\u0985\u0986\7\u0099\2\2\u0986\u0988\5\u0198\u00cd\2\u0987"+
"\u0985\3\2\2\2\u0988\u098b\3\2\2\2\u0989\u0987\3\2\2\2\u0989\u098a\3\2"+
"\2\2\u098a\u098c\3\2\2\2\u098b\u0989\3\2\2\2\u098c\u098d\7\u0093\2\2\u098d"+
"\u09b1\3\2\2\2\u098e\u098f\7M\2\2\u098f\u0990\7\u0092\2\2\u0990\u0991"+
"\5\u0122\u0092\2\u0991\u0992\7\u0093\2\2\u0992\u09b1\3\2\2\2\u0993\u0994"+
"\7N\2\2\u0994\u0995\7\u0092\2\2\u0995\u0996\5\u0122\u0092\2\u0996\u0997"+
"\t\n\2\2\u0997\u099a\5\u0198\u00cd\2\u0998\u0999\7\u0099\2\2\u0999\u099b"+
"\5\u01a4\u00d3\2\u099a\u0998\3\2\2\2\u099a\u099b\3\2\2\2\u099b\u099c\3"+
"\2\2\2\u099c\u099e\7\u0093\2\2\u099d\u099f\5\u013e\u00a0\2\u099e\u099d"+
"\3\2\2\2\u099e\u099f\3\2\2\2\u099f\u09b1\3\2\2\2\u09a0\u09a1\7I\2\2\u09a1"+
"\u09a2\7\u0092\2\2\u09a2\u09a3\5\u01c2\u00e2\2\u09a3\u09a4\7\u0093\2\2"+
"\u09a4\u09b1\3\2\2\2\u09a5\u09a8\7O\2\2\u09a6\u09a7\7\u0092\2\2\u09a7"+
"\u09a9\7\u0093\2\2\u09a8\u09a6\3\2\2\2\u09a8\u09a9\3\2\2\2\u09a9\u09ab"+
"\3\2\2\2\u09aa\u09ac\5\u013e\u00a0\2\u09ab\u09aa\3\2\2\2\u09ab\u09ac\3"+
"\2\2\2\u09ac\u09b1\3\2\2\2\u09ad\u09ae\7;\2\2\u09ae\u09af\7\u0092\2\2"+
"\u09af\u09b1\7\u0093\2\2\u09b0\u090d\3\2\2\2\u09b0\u0915\3\2\2\2\u09b0"+
"\u091d\3\2\2\2\u09b0\u0926\3\2\2\2\u09b0\u092e\3\2\2\2\u09b0\u0936\3\2"+
"\2\2\u09b0\u093e\3\2\2\2\u09b0\u093f\3\2\2\2\u09b0\u094d\3\2\2\2\u09b0"+
"\u0958\3\2\2\2\u09b0\u0963\3\2\2\2\u09b0\u0968\3\2\2\2\u09b0\u096f\3\2"+
"\2\2\u09b0\u0976\3\2\2\2\u09b0\u097b\3\2\2\2\u09b0\u0980\3\2\2\2\u09b0"+
"\u098e\3\2\2\2\u09b0\u0993\3\2\2\2\u09b0\u09a0\3\2\2\2\u09b0\u09a5\3\2"+
"\2\2\u09b0\u09ad\3\2\2\2\u09b1\u014f\3\2\2\2\u09b2\u09b6\7\62\2\2\u09b3"+
"\u09b6\7\63\2\2\u09b4\u09b6\7\4\2\2\u09b5\u09b2\3\2\2\2\u09b5\u09b3\3"+
"\2\2\2\u09b5\u09b4\3\2\2\2\u09b6\u09b7\3\2\2\2\u09b7\u09b9\7\u0092\2\2"+
"\u09b8\u09ba\5\u019c\u00cf\2\u09b9\u09b8\3\2\2\2\u09b9\u09ba\3\2\2\2\u09ba"+
"\u09bb\3\2\2\2\u09bb\u09bd\7\u0093\2\2\u09bc\u09be\5\u013e\u00a0\2\u09bd"+
"\u09bc\3\2\2\2\u09bd\u09be\3\2\2\2\u09be\u0151\3\2\2\2\u09bf\u09c2\5\u01c2"+
"\u00e2\2\u09c0\u09c2\5\u0154\u00ab\2\u09c1\u09bf\3\2\2\2\u09c1\u09c0\3"+
"\2\2\2\u09c2\u0153\3\2\2\2\u09c3\u09c8\5\u0156\u00ac\2\u09c4\u09c5\7\u00b7"+
"\2\2\u09c5\u09c7\5\u0158\u00ad\2\u09c6\u09c4\3\2\2\2\u09c7\u09ca\3\2\2"+
"\2\u09c8\u09c6\3\2\2\2\u09c8\u09c9\3\2\2\2\u09c9\u0155\3\2\2\2\u09ca\u09c8"+
"\3\2\2\2\u09cb\u09cc\5\u0198\u00cd\2\u09cc\u09cd\7\u00b7\2\2\u09cd\u09ce"+
"\5\u015c\u00af\2\u09ce\u09d1\3\2\2\2\u09cf\u09d1\5\u015a\u00ae\2\u09d0"+
"\u09cb\3\2\2\2\u09d0\u09cf\3\2\2\2\u09d1\u09d7\3\2\2\2\u09d2\u09d4\7\u0092"+
"\2\2\u09d3\u09d5\5\u0160\u00b1\2\u09d4\u09d3\3\2\2\2\u09d4\u09d5\3\2\2"+
"\2\u09d5\u09d6\3\2\2\2\u09d6\u09d8\7\u0093\2\2\u09d7\u09d2\3\2\2\2\u09d7"+
"\u09d8\3\2\2\2\u09d8\u0157\3\2\2\2\u09d9\u09df\5\u015e\u00b0\2\u09da\u09dc"+
"\7\u0092\2\2\u09db\u09dd\5\u0160\u00b1\2\u09dc\u09db\3\2\2\2\u09dc\u09dd"+
"\3\2\2\2\u09dd\u09de\3\2\2\2\u09de\u09e0\7\u0093\2\2\u09df\u09da\3\2\2"+
"\2\u09df\u09e0\3\2\2\2\u09e0\u0159\3\2\2\2\u09e1\u09e5\5\u01cc\u00e7\2"+
"\u09e2\u09e5\7\23\2\2\u09e3\u09e5\7\24\2\2\u09e4\u09e1\3\2\2\2\u09e4\u09e2"+
"\3\2\2\2\u09e4\u09e3\3\2\2\2\u09e5\u015b\3\2\2\2\u09e6\u09eb\5\u01cc\u00e7"+
"\2\u09e7\u09eb\7\63\2\2\u09e8\u09eb\7\62\2\2\u09e9\u09eb\7\4\2\2\u09ea"+
"\u09e6\3\2\2\2\u09ea\u09e7\3\2\2\2\u09ea\u09e8\3\2\2\2\u09ea\u09e9\3\2"+
"\2\2\u09eb\u015d\3\2\2\2\u09ec\u09f7\5\u01cc\u00e7\2\u09ed\u09f7\7\63"+
"\2\2\u09ee\u09f7\7\62\2\2\u09ef\u09f7\7\4\2\2\u09f0\u09f7\7\23\2\2\u09f1"+
"\u09f7\7\24\2\2\u09f2\u09f7\7\17\2\2\u09f3\u09f7\7R\2\2\u09f4\u09f7\7"+
"y\2\2\u09f5\u09f7\7\6\2\2\u09f6\u09ec\3\2\2\2\u09f6\u09ed\3\2\2\2\u09f6"+
"\u09ee\3\2\2\2\u09f6\u09ef\3\2\2\2\u09f6\u09f0\3\2\2\2\u09f6\u09f1\3\2"+
"\2\2\u09f6\u09f2\3\2\2\2\u09f6\u09f3\3\2\2\2\u09f6\u09f4\3\2\2\2\u09f6"+
"\u09f5\3\2\2\2\u09f7\u015f\3\2\2\2\u09f8\u09fa\t\t\2\2\u09f9\u09f8\3\2"+
"\2\2\u09f9\u09fa\3\2\2\2\u09fa\u09fb\3\2\2\2\u09fb\u0a00\5\u0162\u00b2"+
"\2\u09fc\u09fd\7\u0099\2\2\u09fd\u09ff\5\u0162\u00b2\2\u09fe\u09fc\3\2"+
"\2\2\u09ff\u0a02\3\2\2\2\u0a00\u09fe\3\2\2\2\u0a00\u0a01\3\2\2\2\u0a01"+
"\u0161\3\2\2\2\u0a02\u0a00\3\2\2\2\u0a03\u0a05\5\20\t\2\u0a04\u0a03\3"+
"\2\2\2\u0a04\u0a05\3\2\2\2\u0a05\u0a06\3\2\2\2\u0a06\u0a07\5\u01a0\u00d1"+
"\2\u0a07\u0163\3\2\2\2\u0a08\u0a09\5\u0134\u009b\2\u0a09\u0a0a\7\13\2"+
"\2\u0a0a\u0a0b\5\u0134\u009b\2\u0a0b\u0165\3\2\2\2\u0a0c\u0a0d\5\u0168"+
"\u00b5\2\u0a0d\u0167\3\2\2\2\u0a0e\u0a12\5\u016c\u00b7\2\u0a0f\u0a11\5"+
"\u016a\u00b6\2\u0a10\u0a0f\3\2\2\2\u0a11\u0a14\3\2\2\2\u0a12\u0a10\3\2"+
"\2\2\u0a12\u0a13\3\2\2\2\u0a13\u0169\3\2\2\2\u0a14\u0a12\3\2\2\2\u0a15"+
"\u0a1b\7\u008d\2\2\u0a16\u0a17\7\u008b\2\2\u0a17\u0a18\5\u0122\u0092\2"+
"\u0a18\u0a19\7\u008c\2\2\u0a19\u0a1b\3\2\2\2\u0a1a\u0a15\3\2\2\2\u0a1a"+
"\u0a16\3\2\2\2\u0a1b\u0a1c\3\2\2\2\u0a1c\u0a1d\5\u016c\u00b7\2\u0a1d\u016b"+
"\3\2\2\2\u0a1e\u0a23\5\u016e\u00b8\2\u0a1f\u0a20\7\n\2\2\u0a20\u0a22\5"+
"\u016e\u00b8\2\u0a21\u0a1f\3\2\2\2\u0a22\u0a25\3\2\2\2\u0a23\u0a21\3\2"+
"\2\2\u0a23\u0a24\3\2\2\2\u0a24\u016d\3\2\2\2\u0a25\u0a23\3\2\2\2\u0a26"+
"\u0a2b\5\u0170\u00b9\2\u0a27\u0a28\7\13\2\2\u0a28\u0a2a\5\u0170\u00b9"+
"\2\u0a29\u0a27\3\2\2\2\u0a2a\u0a2d\3\2\2\2\u0a2b\u0a29\3\2\2\2\u0a2b\u0a2c"+
"\3\2\2\2\u0a2c\u016f\3\2\2\2\u0a2d\u0a2b\3\2\2\2\u0a2e\u0a30\5\u0182\u00c2"+
"\2\u0a2f\u0a2e\3\2\2\2\u0a2f\u0a30\3\2\2\2\u0a30\u0a31\3\2\2\2\u0a31\u0a34"+
"\5\u0172\u00ba\2\u0a32\u0a33\7U\2\2\u0a33\u0a35\5\u0172\u00ba\2\u0a34"+
"\u0a32\3\2\2\2\u0a34\u0a35\3\2\2\2\u0a35\u0171\3\2\2\2\u0a36\u0a3b\7\r"+
"\2\2\u0a37\u0a3b\7\f\2\2\u0a38\u0a39\7\16\2\2\u0a39\u0a3b\5\u0176\u00bc"+
"\2\u0a3a\u0a36\3\2\2\2\u0a3a\u0a37\3\2\2\2\u0a3a\u0a38\3\2\2\2\u0a3b\u0a3d"+
"\3\2\2\2\u0a3c\u0a3e\5\u0182\u00c2\2\u0a3d\u0a3c\3\2\2\2\u0a3d\u0a3e\3"+
"\2\2\2\u0a3e\u0a40\3\2\2\2\u0a3f\u0a3a\3\2\2\2\u0a3f\u0a40\3\2\2\2\u0a40"+
"\u0a41\3\2\2\2\u0a41\u0a42\5\u0174\u00bb\2\u0a42\u0173\3\2\2\2\u0a43\u0a49"+
"\5\u017a\u00be\2\u0a44\u0a45\7\u0092\2\2\u0a45\u0a46\5\u0166\u00b4\2\u0a46"+
"\u0a47\7\u0093\2\2\u0a47\u0a49\3\2\2\2\u0a48\u0a43\3\2\2\2\u0a48\u0a44"+
"\3\2\2\2\u0a49\u0a4e\3\2\2\2\u0a4a\u0a4b\7\17\2\2\u0a4b\u0a4f\5\u017e"+
"\u00c0\2\u0a4c\u0a4d\7{\2\2\u0a4d\u0a4f\5\u0180\u00c1\2\u0a4e\u0a4a\3"+
"\2\2\2\u0a4e\u0a4c\3\2\2\2\u0a4e\u0a4f\3\2\2\2\u0a4f\u0175\3\2\2\2\u0a50"+
"\u0a51\7\u0092\2\2\u0a51\u0a56\5\u0178\u00bd\2\u0a52\u0a53\7\u0099\2\2"+
"\u0a53\u0a55\5\u0178\u00bd\2\u0a54\u0a52\3\2\2\2\u0a55\u0a58\3\2\2\2\u0a56"+
"\u0a54\3\2\2\2\u0a56\u0a57\3\2\2\2\u0a57\u0a59\3\2\2\2\u0a58\u0a56\3\2"+
"\2\2\u0a59\u0a5a\7\u0093\2\2\u0a5a\u0177\3\2\2\2\u0a5b\u0a5c\5\u01ac\u00d7"+
"\2\u0a5c\u0179\3\2\2\2\u0a5d\u0a60\5\u017c\u00bf\2\u0a5e\u0a60\5\u0194"+
"\u00cb\2\u0a5f\u0a5d\3\2\2\2\u0a5f\u0a5e\3\2\2\2\u0a60\u017b\3\2\2\2\u0a61"+
"\u0a62\7\u00c5\2\2\u0a62\u0a65\7\u0098\2\2\u0a63\u0a66\7\u00c5\2\2\u0a64"+
"\u0a66\7V\2\2\u0a65\u0a63\3\2\2\2\u0a65\u0a64\3\2\2\2\u0a66\u0a67\3\2"+
"\2\2\u0a67\u0a69\7\u0092\2\2\u0a68\u0a6a\5\u019e\u00d0\2\u0a69\u0a68\3"+
"\2\2\2\u0a69\u0a6a\3\2\2\2\u0a6a\u0a6b\3\2\2\2\u0a6b\u0a6c\7\u0093\2\2"+
"\u0a6c\u017d\3\2\2\2\u0a6d\u0a6e\7\u00c5\2\2\u0a6e\u0a6f\7\u0098\2\2\u0a6f"+
"\u0a70\7\u00c5\2\2\u0a70\u0a72\7\u0092\2\2\u0a71\u0a73\5\u01aa\u00d6\2"+
"\u0a72\u0a71\3\2\2\2\u0a72\u0a73\3\2\2\2\u0a73\u0a74\3\2\2\2\u0a74\u0a75"+
"\7\u0093\2\2\u0a75\u017f\3\2\2\2\u0a76\u0a77\7\u0092\2\2\u0a77\u0a78\5"+
"\u0122\u0092\2\u0a78\u0a79\7\u0093\2\2\u0a79\u0181\3\2\2\2\u0a7a\u0a84"+
"\7\u0094\2\2\u0a7b\u0a80\5\u0122\u0092\2\u0a7c\u0a7e\7\u0098\2\2\u0a7d"+
"\u0a7f\5\u0122\u0092\2\u0a7e\u0a7d\3\2\2\2\u0a7e\u0a7f\3\2\2\2\u0a7f\u0a81"+
"\3\2\2\2\u0a80\u0a7c\3\2\2\2\u0a80\u0a81\3\2\2\2\u0a81\u0a85\3\2\2\2\u0a82"+
"\u0a83\7\u0098\2\2\u0a83\u0a85\5\u0122\u0092\2\u0a84\u0a7b\3\2\2\2\u0a84"+
"\u0a82\3\2\2\2\u0a85\u0a86\3\2\2\2\u0a86\u0a87\7\u0095\2\2\u0a87\u0183"+
"\3\2\2\2\u0a88\u0a89\7\u00c5\2\2\u0a89\u0a8b\7\u008f\2\2\u0a8a\u0a88\3"+
"\2\2\2\u0a8a\u0a8b\3\2\2\2\u0a8b\u0a8c\3\2\2\2\u0a8c\u0a92\5\u0198\u00cd"+
"\2\u0a8d\u0a8f\7\u0092\2\2\u0a8e\u0a90\5\u01a8\u00d5\2\u0a8f\u0a8e\3\2"+
"\2\2\u0a8f\u0a90\3\2\2\2\u0a90\u0a91\3\2\2\2\u0a91\u0a93\7\u0093\2\2\u0a92"+
"\u0a8d\3\2\2\2\u0a92\u0a93\3\2\2\2\u0a93\u0a95\3\2\2\2\u0a94\u0a96\5\u0186"+
"\u00c4\2\u0a95\u0a94\3\2\2\2\u0a95\u0a96\3\2\2\2\u0a96\u0185\3\2\2\2\u0a97"+
"\u0a9b\5\u0188\u00c5\2\u0a98\u0a9a\5\u0188\u00c5\2\u0a99\u0a98\3\2\2\2"+
"\u0a9a\u0a9d\3\2\2\2\u0a9b\u0a99\3\2\2\2\u0a9b\u0a9c\3\2\2\2\u0a9c\u0187"+
"\3\2\2\2\u0a9d\u0a9b\3\2\2\2\u0a9e\u0aa0\7\u0094\2\2\u0a9f\u0aa1\5\u018a"+
"\u00c6\2\u0aa0\u0a9f\3\2\2\2\u0aa0\u0aa1\3\2\2\2\u0aa1\u0aa2\3\2\2\2\u0aa2"+
"\u0aa4\5\u0122\u0092\2\u0aa3\u0aa5\5\u0192\u00ca\2\u0aa4\u0aa3\3\2\2\2"+
"\u0aa4\u0aa5\3\2\2\2\u0aa5\u0aa8\3\2\2\2\u0aa6\u0aa7\7\20\2\2\u0aa7\u0aa9"+
"\7\u00c5\2\2\u0aa8\u0aa6\3\2\2\2\u0aa8\u0aa9\3\2\2\2\u0aa9\u0aac\3\2\2"+
"\2\u0aaa\u0aab\7\17\2\2\u0aab\u0aad\5\u0122\u0092\2\u0aac\u0aaa\3\2\2"+
"\2\u0aac\u0aad\3\2\2\2\u0aad\u0aae\3\2\2\2\u0aae\u0aaf\7\u0095\2\2\u0aaf"+
"\u0189\3\2\2\2\u0ab0\u0ab1\7\32\2\2\u0ab1\u0ab2\5\u018c\u00c7\2\u0ab2"+
"\u0ab3\7 \2\2\u0ab3\u018b\3\2\2\2\u0ab4\u0ab9\5\u018e\u00c8\2\u0ab5\u0ab6"+
"\7\u0099\2\2\u0ab6\u0ab8\5\u018e\u00c8\2\u0ab7\u0ab5\3\2\2\2\u0ab8\u0abb"+
"\3\2\2\2\u0ab9\u0ab7\3\2\2\2\u0ab9\u0aba\3\2\2\2\u0aba\u018d\3\2\2\2\u0abb"+
"\u0ab9\3\2\2\2\u0abc\u0ac4\7\u00a6\2\2\u0abd\u0ac4\5\u0190\u00c9\2\u0abe"+
"\u0ac1\5\u0122\u0092\2\u0abf\u0ac0\7\20\2\2\u0ac0\u0ac2\5\u01c8\u00e5"+
"\2\u0ac1\u0abf\3\2\2\2\u0ac1\u0ac2\3\2\2\2\u0ac2\u0ac4\3\2\2\2\u0ac3\u0abc"+
"\3\2\2\2\u0ac3\u0abd\3\2\2\2\u0ac3\u0abe\3\2\2\2\u0ac4\u018f\3\2\2\2\u0ac5"+
"\u0ac6\7\u00c5\2\2\u0ac6\u0ac7\7\u00b7\2\2\u0ac7\u0aca\7\u00a6\2\2\u0ac8"+
"\u0ac9\7\20\2\2\u0ac9\u0acb\7\u00c5\2\2\u0aca\u0ac8\3\2\2\2\u0aca\u0acb"+
"\3\2\2\2\u0acb\u0191\3\2\2\2\u0acc\u0acd\7\u00bd\2\2\u0acd\u0ace\7\u00c5"+
"\2\2\u0ace\u0acf\7\u0092\2\2\u0acf\u0ad0\7\u00c5\2\2\u0ad0\u0ad1\7\u0093"+
"\2\2\u0ad1\u0193\3\2\2\2\u0ad2\u0ad3\7\u00c5\2\2\u0ad3\u0ad5\7\u008f\2"+
"\2\u0ad4\u0ad2\3\2\2\2\u0ad4\u0ad5\3\2\2\2\u0ad5\u0ad6\3\2\2\2\u0ad6\u0adc"+
"\5\u0198\u00cd\2\u0ad7\u0ad9\7\u0092\2\2\u0ad8\u0ada\5\u01a8\u00d5\2\u0ad9"+
"\u0ad8\3\2\2\2\u0ad9\u0ada\3\2\2\2\u0ada\u0adb\3\2\2\2\u0adb\u0add\7\u0093"+
"\2\2\u0adc\u0ad7\3\2\2\2\u0adc\u0add\3\2\2\2\u0add\u0adf\3\2\2\2\u0ade"+
"\u0ae0\5\u0186\u00c4\2\u0adf\u0ade\3\2\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u0ae2"+
"\3\2\2\2\u0ae1\u0ae3\5\u0196\u00cc\2\u0ae2\u0ae1\3\2\2\2\u0ae2\u0ae3\3"+
"\2\2\2\u0ae3\u0195\3\2\2\2\u0ae4\u0ae5\7\u00bd\2\2\u0ae5\u0aea\7\u00c5"+
"\2\2\u0ae6\u0ae7\7\u0092\2\2\u0ae7\u0ae8\5\u01e2\u00f2\2\u0ae8\u0ae9\7"+
"\u0093\2\2\u0ae9\u0aeb\3\2\2\2\u0aea\u0ae6\3\2\2\2\u0aea\u0aeb\3\2\2\2"+
"\u0aeb\u0197\3\2\2\2\u0aec\u0af1\5\u01ca\u00e6\2\u0aed\u0aee\7\u00b7\2"+
"\2\u0aee\u0af0\5\u01ca\u00e6\2\u0aef\u0aed\3\2\2\2\u0af0\u0af3\3\2\2\2"+
"\u0af1\u0aef\3\2\2\2\u0af1\u0af2\3\2\2\2\u0af2\u0199\3\2\2\2\u0af3\u0af1"+
"\3\2\2\2\u0af4\u0af6\7\u009e\2\2\u0af5\u0af4\3\2\2\2\u0af5\u0af6\3\2\2"+
"\2\u0af6\u0af7\3\2\2\2\u0af7\u0afc\5\u01ca\u00e6\2\u0af8\u0af9\7\u009e"+
"\2\2\u0af9\u0afb\5\u01ca\u00e6\2\u0afa\u0af8\3\2\2\2\u0afb\u0afe\3\2\2"+
"\2\u0afc\u0afa\3\2\2\2\u0afc\u0afd\3\2\2\2\u0afd\u019b\3\2\2\2\u0afe\u0afc"+
"\3\2\2\2\u0aff\u0b04\5\u01a0\u00d1\2\u0b00\u0b01\7\u0099\2\2\u0b01\u0b03"+
"\5\u01a0\u00d1\2\u0b02\u0b00\3\2\2\2\u0b03\u0b06\3\2\2\2\u0b04\u0b02\3"+
"\2\2\2\u0b04\u0b05\3\2\2\2\u0b05\u019d\3\2\2\2\u0b06\u0b04\3\2\2\2\u0b07"+
"\u0b0c\5\u01a2\u00d2\2\u0b08\u0b09\7\u0099\2\2\u0b09\u0b0b\5\u01a2\u00d2"+
"\2\u0b0a\u0b08\3\2\2\2\u0b0b\u0b0e\3\2\2\2\u0b0c\u0b0a\3\2\2\2\u0b0c\u0b0d"+
"\3\2\2\2\u0b0d\u019f\3\2\2\2\u0b0e\u0b0c\3\2\2\2\u0b0f\u0b12\5\u01a4\u00d3"+
"\2\u0b10\u0b12\5\u01ac\u00d7\2\u0b11\u0b0f\3\2\2\2\u0b11\u0b10\3\2\2\2"+
"\u0b12\u01a1\3\2\2\2\u0b13\u0b16\5\u01a6\u00d4\2\u0b14\u0b16\5\u01ae\u00d8"+
"\2\u0b15\u0b13\3\2\2\2\u0b15\u0b14\3\2\2\2\u0b16\u01a3\3\2\2\2\u0b17\u0b18"+
"\7\u00c5\2\2\u0b18\u0b1f\7\u0098\2\2\u0b19\u0b20\5\u0122\u0092\2\u0b1a"+
"\u0b1c\7\u0092\2\2\u0b1b\u0b1d\5\u01a8\u00d5\2\u0b1c\u0b1b\3\2\2\2\u0b1c"+
"\u0b1d\3\2\2\2\u0b1d\u0b1e\3\2\2\2\u0b1e\u0b20\7\u0093\2\2\u0b1f\u0b19"+
"\3\2\2\2\u0b1f\u0b1a\3\2\2\2\u0b20\u01a5\3\2\2\2\u0b21\u0b22\7\u00c5\2"+
"\2\u0b22\u0b29\7\u0098\2\2\u0b23\u0b2a\5\u01ac\u00d7\2\u0b24\u0b26\7\u0092"+
"\2\2\u0b25\u0b27\5\u01aa\u00d6\2\u0b26\u0b25\3\2\2\2\u0b26\u0b27\3\2\2"+
"\2\u0b27\u0b28\3\2\2\2\u0b28\u0b2a\7\u0093\2\2\u0b29\u0b23\3\2\2\2\u0b29"+
"\u0b24\3\2\2\2\u0b2a\u01a7\3\2\2\2\u0b2b\u0b30\5\u0122\u0092\2\u0b2c\u0b2d"+
"\7\u0099\2\2\u0b2d\u0b2f\5\u0122\u0092\2\u0b2e\u0b2c\3\2\2\2\u0b2f\u0b32"+
"\3\2\2\2\u0b30\u0b2e\3\2\2\2\u0b30\u0b31\3\2\2\2\u0b31\u01a9\3\2\2\2\u0b32"+
"\u0b30\3\2\2\2\u0b33\u0b38\5\u01ae\u00d8\2\u0b34\u0b35\7\u0099\2\2\u0b35"+
"\u0b37\5\u01ae\u00d8\2\u0b36\u0b34\3\2\2\2\u0b37\u0b3a\3\2\2\2\u0b38\u0b36"+
"\3\2\2\2\u0b38\u0b39\3\2\2\2\u0b39\u01ab\3\2\2\2\u0b3a\u0b38\3\2\2\2\u0b3b"+
"\u0b46\5\u01b2\u00da\2\u0b3c\u0b46\5\u01ce\u00e8\2\u0b3d\u0b46\5\u01b0"+
"\u00d9\2\u0b3e\u0b46\5\u01b8\u00dd\2\u0b3f\u0b46\5\u01b6\u00dc\2\u0b40"+
"\u0b46\5\u01ba\u00de\2\u0b41\u0b46\5\u01bc\u00df\2\u0b42\u0b46\5\u01be"+
"\u00e0\2\u0b43\u0b46\7\u00a6\2\2\u0b44\u0b46\5\u0190\u00c9\2\u0b45\u0b3b"+
"\3\2\2\2\u0b45\u0b3c\3\2\2\2\u0b45\u0b3d\3\2\2\2\u0b45\u0b3e\3\2\2\2\u0b45"+
"\u0b3f\3\2\2\2\u0b45\u0b40\3\2\2\2\u0b45\u0b41\3\2\2\2\u0b45\u0b42\3\2"+
"\2\2\u0b45\u0b43\3\2\2\2\u0b45\u0b44\3\2\2\2\u0b46\u01ad\3\2\2\2\u0b47"+
"\u0b4a\5\u01b4\u00db\2\u0b48\u0b4a\5\u01ac\u00d7\2\u0b49\u0b47\3\2\2\2"+
"\u0b49\u0b48\3\2\2\2\u0b4a\u01af\3\2\2\2\u0b4b\u0b51\5\u0122\u0092\2\u0b4c"+
"\u0b52\78\2\2\u0b4d\u0b52\79\2\2\u0b4e\u0b52\7f\2\2\u0b4f\u0b52\7e\2\2"+
"\u0b50\u0b52\7d\2\2\u0b51\u0b4c\3\2\2\2\u0b51\u0b4d\3\2\2\2\u0b51\u0b4e"+
"\3\2\2\2\u0b51\u0b4f\3\2\2\2\u0b51\u0b50\3\2\2\2\u0b51\u0b52\3\2\2\2\u0b52"+
"\u01b1\3\2\2\2\u0b53\u0b54\7K\2\2\u0b54\u01b3\3\2\2\2\u0b55\u0b56\7\63"+
"\2\2\u0b56\u01b5\3\2\2\2\u0b57\u0b58\7\u00a6\2\2\u0b58\u0b5c\7\u009e\2"+
"\2\u0b59\u0b5d\5\u01e2\u00f2\2\u0b5a\u0b5d\7\u00c5\2\2\u0b5b\u0b5d\5\u01e4"+
"\u00f3\2\u0b5c\u0b59\3\2\2\2\u0b5c\u0b5a\3\2\2\2\u0b5c\u0b5b\3\2\2\2\u0b5d"+
"\u01b7\3\2\2\2\u0b5e\u0b62\5\u01e2\u00f2\2\u0b5f\u0b62\7\u00c5\2\2\u0b60"+
"\u0b62\5\u01e4\u00f3\2\u0b61\u0b5e\3\2\2\2\u0b61\u0b5f\3\2\2\2\u0b61\u0b60"+
"\3\2\2\2\u0b62\u0b63\3\2\2\2\u0b63\u0b67\7\u0098\2\2\u0b64\u0b68\5\u01e2"+
"\u00f2\2\u0b65\u0b68\7\u00c5\2\2\u0b66\u0b68\5\u01e4\u00f3\2\u0b67\u0b64"+
"\3\2\2\2\u0b67\u0b65\3\2\2\2\u0b67\u0b66\3\2\2\2\u0b68\u01b9\3\2\2\2\u0b69"+
"\u0b6d\5\u01e2\u00f2\2\u0b6a\u0b6d\7\u00c5\2\2\u0b6b\u0b6d\5\u01e4\u00f3"+
"\2\u0b6c\u0b69\3\2\2\2\u0b6c\u0b6a\3\2\2\2\u0b6c\u0b6b\3\2\2\2\u0b6d\u0b6e"+
"\3\2\2\2\u0b6e\u0b6f\7\63\2\2\u0b6f\u01bb\3\2\2\2\u0b70\u0b74\5\u01e2"+
"\u00f2\2\u0b71\u0b74\7\u00c5\2\2\u0b72\u0b74\5\u01e4\u00f3\2\u0b73\u0b70"+
"\3\2\2\2\u0b73\u0b71\3\2\2\2\u0b73\u0b72\3\2\2\2\u0b74\u0b75\3\2\2\2\u0b75"+
"\u0b76\7J\2\2\u0b76\u01bd\3\2\2\2\u0b77\u0b78\7\u0094\2\2\u0b78\u0b7d"+
"\5\u01c0\u00e1\2\u0b79\u0b7a\7\u0099\2\2\u0b7a\u0b7c\5\u01c0\u00e1\2\u0b7b"+
"\u0b79\3\2\2\2\u0b7c\u0b7f\3\2\2\2\u0b7d\u0b7b\3\2\2\2\u0b7d\u0b7e\3\2"+
"\2\2\u0b7e\u0b80\3\2\2\2\u0b7f\u0b7d\3\2\2\2\u0b80\u0b81\7\u0095\2\2\u0b81"+
"\u01bf\3\2\2\2\u0b82\u0b86\5\u01b8\u00dd\2\u0b83\u0b86\5\u01b6\u00dc\2"+
"\u0b84\u0b86\5\u01e8\u00f5\2\u0b85\u0b82\3\2\2\2\u0b85\u0b83\3\2\2\2\u0b85"+
"\u0b84\3\2\2\2\u0b86\u01c1\3\2\2\2\u0b87\u0b8c\5\u01c4\u00e3\2\u0b88\u0b89"+
"\7\u00b7\2\2\u0b89\u0b8b\5\u01c4\u00e3\2\u0b8a\u0b88\3\2\2\2\u0b8b\u0b8e"+
"\3\2\2\2\u0b8c\u0b8a\3\2\2\2\u0b8c\u0b8d\3\2\2\2\u0b8d\u01c3\3\2\2\2\u0b8e"+
"\u0b8c\3\2\2\2\u0b8f\u0ba0\5\u01c6\u00e4\2\u0b90\u0b91\7\u0094\2\2\u0b91"+
"\u0b92\5\u01e2\u00f2\2\u0b92\u0b94\7\u0095\2\2\u0b93\u0b95\7\u0091\2\2"+
"\u0b94\u0b93\3\2\2\2\u0b94\u0b95\3\2\2\2\u0b95\u0ba1\3\2\2\2\u0b96\u0b99"+
"\7\u0092\2\2\u0b97\u0b9a\7\u00c4\2\2\u0b98\u0b9a\7\u00c3\2\2\u0b99\u0b97"+
"\3\2\2\2\u0b99\u0b98\3\2\2\2\u0b9a\u0b9b\3\2\2\2\u0b9b\u0b9d\7\u0093\2"+
"\2\u0b9c\u0b9e\7\u0091\2\2\u0b9d\u0b9c\3\2\2\2\u0b9d\u0b9e\3\2\2\2\u0b9e"+
"\u0ba1\3\2\2\2\u0b9f\u0ba1\7\u0091\2\2\u0ba0\u0b90\3\2\2\2\u0ba0\u0b96"+
"\3\2\2\2\u0ba0\u0b9f\3\2\2\2\u0ba0\u0ba1\3\2\2\2\u0ba1\u01c5\3\2\2\2\u0ba2"+
"\u0baa\5\u01c8\u00e5\2\u0ba3\u0ba4\7\u00bb\2\2\u0ba4\u0ba6\7\u00b7\2\2"+
"\u0ba5\u0ba7\5\u01c8\u00e5\2\u0ba6\u0ba5\3\2\2\2\u0ba6\u0ba7\3\2\2\2\u0ba7"+
"\u0ba9\3\2\2\2\u0ba8\u0ba3\3\2\2\2\u0ba9\u0bac\3\2\2\2\u0baa\u0ba8\3\2"+
"\2\2\u0baa\u0bab\3\2\2\2\u0bab\u01c7\3\2\2\2\u0bac\u0baa\3\2\2\2\u0bad"+
"\u0be2\7\u00c5\2\2\u0bae\u0be2\7\u00c2\2\2\u0baf\u0be2\7V\2\2\u0bb0\u0be2"+
"\7\31\2\2\u0bb1\u0be2\7\t\2\2\u0bb2\u0be2\7\r\2\2\u0bb3\u0be2\7=\2\2\u0bb4"+
"\u0be2\7\21\2\2\u0bb5\u0be2\7\22\2\2\u0bb6\u0be2\7\23\2\2\u0bb7\u0be2"+
"\7\24\2\2\u0bb8\u0be2\7\25\2\2\u0bb9\u0be2\7\26\2\2\u0bba\u0be2\7\27\2"+
"\2\u0bbb\u0be2\7\30\2\2\u0bbc\u0be2\7\61\2\2\u0bbd\u0be2\7\62\2\2\u0bbe"+
"\u0be2\7\63\2\2\u0bbf\u0be2\7{\2\2\u0bc0\u0be2\7}\2\2\u0bc1\u0be2\7~\2"+
"\2\u0bc2\u0be2\7>\2\2\u0bc3\u0be2\7?\2\2\u0bc4\u0be2\7@\2\2\u0bc5\u0be2"+
"\7U\2\2\u0bc6\u0be2\7A\2\2\u0bc7\u0be2\7B\2\2\u0bc8\u0be2\7C\2\2\u0bc9"+
"\u0be2\7D\2\2\u0bca\u0be2\7E\2\2\u0bcb\u0be2\7H\2\2\u0bcc\u0be2\7J\2\2"+
"\u0bcd\u0be2\7K\2\2\u0bce\u0be2\7L\2\2\u0bcf\u0be2\7M\2\2\u0bd0\u0be2"+
"\7N\2\2\u0bd1\u0be2\7Q\2\2\u0bd2\u0be2\7S\2\2\u0bd3\u0be2\7T\2\2\u0bd4"+
"\u0be2\7W\2\2\u0bd5\u0be2\7\4\2\2\u0bd6\u0be2\7$\2\2\u0bd7\u0be2\7%\2"+
"\2\u0bd8\u0be2\7!\2\2\u0bd9\u0be2\7&\2\2\u0bda\u0be2\7#\2\2\u0bdb\u0be2"+
"\7v\2\2\u0bdc\u0be2\7w\2\2\u0bdd\u0be2\7x\2\2\u0bde\u0be2\7\u0082\2\2"+
"\u0bdf\u0be2\7z\2\2\u0be0\u0be2\7|\2\2\u0be1\u0bad\3\2\2\2\u0be1\u0bae"+
"\3\2\2\2\u0be1\u0baf\3\2\2\2\u0be1\u0bb0\3\2\2\2\u0be1\u0bb1\3\2\2\2\u0be1"+
"\u0bb2\3\2\2\2\u0be1\u0bb3\3\2\2\2\u0be1\u0bb4\3\2\2\2\u0be1\u0bb5\3\2"+
"\2\2\u0be1\u0bb6\3\2\2\2\u0be1\u0bb7\3\2\2\2\u0be1\u0bb8\3\2\2\2\u0be1"+
"\u0bb9\3\2\2\2\u0be1\u0bba\3\2\2\2\u0be1\u0bbb\3\2\2\2\u0be1\u0bbc\3\2"+
"\2\2\u0be1\u0bbd\3\2\2\2\u0be1\u0bbe\3\2\2\2\u0be1\u0bbf\3\2\2\2\u0be1"+
"\u0bc0\3\2\2\2\u0be1\u0bc1\3\2\2\2\u0be1\u0bc2\3\2\2\2\u0be1\u0bc3\3\2"+
"\2\2\u0be1\u0bc4\3\2\2\2\u0be1\u0bc5\3\2\2\2\u0be1\u0bc6\3\2\2\2\u0be1"+
"\u0bc7\3\2\2\2\u0be1\u0bc8\3\2\2\2\u0be1\u0bc9\3\2\2\2\u0be1\u0bca\3\2"+
"\2\2\u0be1\u0bcb\3\2\2\2\u0be1\u0bcc\3\2\2\2\u0be1\u0bcd\3\2\2\2\u0be1"+
"\u0bce\3\2\2\2\u0be1\u0bcf\3\2\2\2\u0be1\u0bd0\3\2\2\2\u0be1\u0bd1\3\2"+
"\2\2\u0be1\u0bd2\3\2\2\2\u0be1\u0bd3\3\2\2\2\u0be1\u0bd4\3\2\2\2\u0be1"+
"\u0bd5\3\2\2\2\u0be1\u0bd6\3\2\2\2\u0be1\u0bd7\3\2\2\2\u0be1\u0bd8\3\2"+
"\2\2\u0be1\u0bd9\3\2\2\2\u0be1\u0bda\3\2\2\2\u0be1\u0bdb\3\2\2\2\u0be1"+
"\u0bdc\3\2\2\2\u0be1\u0bdd\3\2\2\2\u0be1\u0bde\3\2\2\2\u0be1\u0bdf\3\2"+
"\2\2\u0be1\u0be0\3\2\2\2\u0be2\u01c9\3\2\2\2\u0be3\u0be7\7\u00c5\2\2\u0be4"+
"\u0be7\7\61\2\2\u0be5\u0be7\7\u00c2\2\2\u0be6\u0be3\3\2\2\2\u0be6\u0be4"+
"\3\2\2\2\u0be6\u0be5\3\2\2\2\u0be7\u01cb\3\2\2\2\u0be8\u0beb\7\u00c5\2"+
"\2\u0be9\u0beb\7\u00c2\2\2\u0bea\u0be8\3\2\2\2\u0bea\u0be9\3\2\2\2\u0beb"+
"\u01cd\3\2\2\2\u0bec\u0bee\5\u01d0\u00e9\2\u0bed\u0bef\5\u01d2\u00ea\2"+
"\u0bee\u0bed\3\2\2\2\u0bee\u0bef\3\2\2\2\u0bef\u0bf1\3\2\2\2\u0bf0\u0bf2"+
"\5\u01d4\u00eb\2\u0bf1\u0bf0\3\2\2\2\u0bf1\u0bf2\3\2\2\2\u0bf2\u0bf4\3"+
"\2\2\2\u0bf3\u0bf5\5\u01d6\u00ec\2\u0bf4\u0bf3\3\2\2\2\u0bf4\u0bf5\3\2"+
"\2\2\u0bf5\u0bf7\3\2\2\2\u0bf6\u0bf8\5\u01d8\u00ed\2\u0bf7\u0bf6\3\2\2"+
"\2\u0bf7\u0bf8\3\2\2\2\u0bf8\u0bfa\3\2\2\2\u0bf9\u0bfb\5\u01da\u00ee\2"+
"\u0bfa\u0bf9\3\2\2\2\u0bfa\u0bfb\3\2\2\2\u0bfb\u0bfd\3\2\2\2\u0bfc\u0bfe"+
"\5\u01dc\u00ef\2\u0bfd\u0bfc\3\2\2\2\u0bfd\u0bfe\3\2\2\2\u0bfe\u0c00\3"+
"\2\2\2\u0bff\u0c01\5\u01de\u00f0\2\u0c00\u0bff\3\2\2\2\u0c00\u0c01\3\2"+
"\2\2\u0c01\u0c03\3\2\2\2\u0c02\u0c04\5\u01e0\u00f1\2\u0c03\u0c02\3\2\2"+
"\2\u0c03\u0c04\3\2\2\2\u0c04\u0c62\3\2\2\2\u0c05\u0c07\5\u01d2\u00ea\2"+
"\u0c06\u0c08\5\u01d4\u00eb\2\u0c07\u0c06\3\2\2\2\u0c07\u0c08\3\2\2\2\u0c08"+
"\u0c0a\3\2\2\2\u0c09\u0c0b\5\u01d6\u00ec\2\u0c0a\u0c09\3\2\2\2\u0c0a\u0c0b"+
"\3\2\2\2\u0c0b\u0c0d\3\2\2\2\u0c0c\u0c0e\5\u01d8\u00ed\2\u0c0d\u0c0c\3"+
"\2\2\2\u0c0d\u0c0e\3\2\2\2\u0c0e\u0c10\3\2\2\2\u0c0f\u0c11\5\u01da\u00ee"+
"\2\u0c10\u0c0f\3\2\2\2\u0c10\u0c11\3\2\2\2\u0c11\u0c13\3\2\2\2\u0c12\u0c14"+
"\5\u01dc\u00ef\2\u0c13\u0c12\3\2\2\2\u0c13\u0c14\3\2\2\2\u0c14\u0c16\3"+
"\2\2\2\u0c15\u0c17\5\u01de\u00f0\2\u0c16\u0c15\3\2\2\2\u0c16\u0c17\3\2"+
"\2\2\u0c17\u0c19\3\2\2\2\u0c18\u0c1a\5\u01e0\u00f1\2\u0c19\u0c18\3\2\2"+
"\2\u0c19\u0c1a\3\2\2\2\u0c1a\u0c62\3\2\2\2\u0c1b\u0c1d\5\u01d4\u00eb\2"+
"\u0c1c\u0c1e\5\u01d6\u00ec\2\u0c1d\u0c1c\3\2\2\2\u0c1d\u0c1e\3\2\2\2\u0c1e"+
"\u0c20\3\2\2\2\u0c1f\u0c21\5\u01d8\u00ed\2\u0c20\u0c1f\3\2\2\2\u0c20\u0c21"+
"\3\2\2\2\u0c21\u0c23\3\2\2\2\u0c22\u0c24\5\u01da\u00ee\2\u0c23\u0c22\3"+
"\2\2\2\u0c23\u0c24\3\2\2\2\u0c24\u0c26\3\2\2\2\u0c25\u0c27\5\u01dc\u00ef"+
"\2\u0c26\u0c25\3\2\2\2\u0c26\u0c27\3\2\2\2\u0c27\u0c29\3\2\2\2\u0c28\u0c2a"+
"\5\u01de\u00f0\2\u0c29\u0c28\3\2\2\2\u0c29\u0c2a\3\2\2\2\u0c2a\u0c2c\3"+
"\2\2\2\u0c2b\u0c2d\5\u01e0\u00f1\2\u0c2c\u0c2b\3\2\2\2\u0c2c\u0c2d\3\2"+
"\2\2\u0c2d\u0c62\3\2\2\2\u0c2e\u0c30\5\u01d6\u00ec\2\u0c2f\u0c31\5\u01d8"+
"\u00ed\2\u0c30\u0c2f\3\2\2\2\u0c30\u0c31\3\2\2\2\u0c31\u0c33\3\2\2\2\u0c32"+
"\u0c34\5\u01da\u00ee\2\u0c33\u0c32\3\2\2\2\u0c33\u0c34\3\2\2\2\u0c34\u0c36"+
"\3\2\2\2\u0c35\u0c37\5\u01dc\u00ef\2\u0c36\u0c35\3\2\2\2\u0c36\u0c37\3"+
"\2\2\2\u0c37\u0c39\3\2\2\2\u0c38\u0c3a\5\u01de\u00f0\2\u0c39\u0c38\3\2"+
"\2\2\u0c39\u0c3a\3\2\2\2\u0c3a\u0c3c\3\2\2\2\u0c3b\u0c3d\5\u01e0\u00f1"+
"\2\u0c3c\u0c3b\3\2\2\2\u0c3c\u0c3d\3\2\2\2\u0c3d\u0c62\3\2\2\2\u0c3e\u0c40"+
"\5\u01d8\u00ed\2\u0c3f\u0c41\5\u01da\u00ee\2\u0c40\u0c3f\3\2\2\2\u0c40"+
"\u0c41\3\2\2\2\u0c41\u0c43\3\2\2\2\u0c42\u0c44\5\u01dc\u00ef\2\u0c43\u0c42"+
"\3\2\2\2\u0c43\u0c44\3\2\2\2\u0c44\u0c46\3\2\2\2\u0c45\u0c47\5\u01de\u00f0"+
"\2\u0c46\u0c45\3\2\2\2\u0c46\u0c47\3\2\2\2\u0c47\u0c49\3\2\2\2\u0c48\u0c4a"+
"\5\u01e0\u00f1\2\u0c49\u0c48\3\2\2\2\u0c49\u0c4a\3\2\2\2\u0c4a\u0c62\3"+
"\2\2\2\u0c4b\u0c4d\5\u01da\u00ee\2\u0c4c\u0c4e\5\u01dc\u00ef\2\u0c4d\u0c4c"+
"\3\2\2\2\u0c4d\u0c4e\3\2\2\2\u0c4e\u0c50\3\2\2\2\u0c4f\u0c51\5\u01de\u00f0"+
"\2\u0c50\u0c4f\3\2\2\2\u0c50\u0c51\3\2\2\2\u0c51\u0c53\3\2\2\2\u0c52\u0c54"+
"\5\u01e0\u00f1\2\u0c53\u0c52\3\2\2\2\u0c53\u0c54\3\2\2\2\u0c54\u0c62\3"+
"\2\2\2\u0c55\u0c57\5\u01dc\u00ef\2\u0c56\u0c58\5\u01de\u00f0\2\u0c57\u0c56"+
"\3\2\2\2\u0c57\u0c58\3\2\2\2\u0c58\u0c5a\3\2\2\2\u0c59\u0c5b\5\u01e0\u00f1"+
"\2\u0c5a\u0c59\3\2\2\2\u0c5a\u0c5b\3\2\2\2\u0c5b\u0c62\3\2\2\2\u0c5c\u0c5e"+
"\5\u01de\u00f0\2\u0c5d\u0c5f\5\u01e0\u00f1\2\u0c5e\u0c5d\3\2\2\2\u0c5e"+
"\u0c5f\3\2\2\2\u0c5f\u0c62\3\2\2\2\u0c60\u0c62\5\u01e0\u00f1\2\u0c61\u0bec"+
"\3\2\2\2\u0c61\u0c05\3\2\2\2\u0c61\u0c1b\3\2\2\2\u0c61\u0c2e\3\2\2\2\u0c61"+
"\u0c3e\3\2\2\2\u0c61\u0c4b\3\2\2\2\u0c61\u0c55\3\2\2\2\u0c61\u0c5c\3\2"+
"\2\2\u0c61\u0c60\3\2\2\2\u0c62\u01cf\3\2\2\2\u0c63\u0c67\5\u01e8\u00f5"+
"\2\u0c64\u0c67\7\u00c5\2\2\u0c65\u0c67\5\u01e4\u00f3\2\u0c66\u0c63\3\2"+
"\2\2\u0c66\u0c64\3\2\2\2\u0c66\u0c65\3\2\2\2\u0c67\u0c68\3\2\2\2\u0c68"+
"\u0c69\t\13\2\2\u0c69\u01d1\3\2\2\2\u0c6a\u0c6e\5\u01e8\u00f5\2\u0c6b"+
"\u0c6e\7\u00c5\2\2\u0c6c\u0c6e\5\u01e4\u00f3\2\u0c6d\u0c6a\3\2\2\2\u0c6d"+
"\u0c6b\3\2\2\2\u0c6d\u0c6c\3\2\2\2\u0c6e\u0c6f\3\2\2\2\u0c6f\u0c70\t\f"+
"\2\2\u0c70\u01d3\3\2\2\2\u0c71\u0c75\5\u01e8\u00f5\2\u0c72\u0c75\7\u00c5"+
"\2\2\u0c73\u0c75\5\u01e4\u00f3\2\u0c74\u0c71\3\2\2\2\u0c74\u0c72\3\2\2"+
"\2\u0c74\u0c73\3\2\2\2\u0c75\u0c76\3\2\2\2\u0c76\u0c77\t\r\2\2\u0c77\u01d5"+
"\3\2\2\2\u0c78\u0c7c\5\u01e8\u00f5\2\u0c79\u0c7c\7\u00c5\2\2\u0c7a\u0c7c"+
"\5\u01e4\u00f3\2\u0c7b\u0c78\3\2\2\2\u0c7b\u0c79\3\2\2\2\u0c7b\u0c7a\3"+
"\2\2\2\u0c7c\u0c7d\3\2\2\2\u0c7d\u0c7e\t\16\2\2\u0c7e\u01d7\3\2\2\2\u0c7f"+
"\u0c83\5\u01e8\u00f5\2\u0c80\u0c83\7\u00c5\2\2\u0c81\u0c83\5\u01e4\u00f3"+
"\2\u0c82\u0c7f\3\2\2\2\u0c82\u0c80\3\2\2\2\u0c82\u0c81\3\2\2\2\u0c83\u0c84"+
"\3\2\2\2\u0c84\u0c85\t\17\2\2\u0c85\u01d9\3\2\2\2\u0c86\u0c8a\5\u01e8"+
"\u00f5\2\u0c87\u0c8a\7\u00c5\2\2\u0c88\u0c8a\5\u01e4\u00f3\2\u0c89\u0c86"+
"\3\2\2\2\u0c89\u0c87\3\2\2\2\u0c89\u0c88\3\2\2\2\u0c8a\u0c8b\3\2\2\2\u0c8b"+
"\u0c8c\t\20\2\2\u0c8c\u01db\3\2\2\2\u0c8d\u0c91\5\u01e8\u00f5\2\u0c8e"+
"\u0c91\7\u00c5\2\2\u0c8f\u0c91\5\u01e4\u00f3\2\u0c90\u0c8d\3\2\2\2\u0c90"+
"\u0c8e\3\2\2\2\u0c90\u0c8f\3\2\2\2\u0c91\u0c92\3\2\2\2\u0c92\u0c93\t\21"+
"\2\2\u0c93\u01dd\3\2\2\2\u0c94\u0c98\5\u01e8\u00f5\2\u0c95\u0c98\7\u00c5"+
"\2\2\u0c96\u0c98\5\u01e4\u00f3\2\u0c97\u0c94\3\2\2\2\u0c97\u0c95\3\2\2"+
"\2\u0c97\u0c96\3\2\2\2\u0c98\u0c99\3\2\2\2\u0c99\u0c9a\t\22\2\2\u0c9a"+
"\u01df\3\2\2\2\u0c9b\u0c9f\5\u01e8\u00f5\2\u0c9c\u0c9f\7\u00c5\2\2\u0c9d"+
"\u0c9f\5\u01e4\u00f3\2\u0c9e\u0c9b\3\2\2\2\u0c9e\u0c9c\3\2\2\2\u0c9e\u0c9d"+
"\3\2\2\2\u0c9f\u0ca0\3\2\2\2\u0ca0\u0ca1\t\23\2\2\u0ca1\u01e1\3\2\2\2"+
"\u0ca2\u0ca3\t\24\2\2\u0ca3\u01e3\3\2\2\2\u0ca4\u0ca7\7\u0091\2\2\u0ca5"+
"\u0ca6\7\u0098\2\2\u0ca6\u0ca8\5\u019a\u00ce\2\u0ca7\u0ca5\3\2\2\2\u0ca7"+
"\u0ca8\3\2\2\2\u0ca8\u01e5\3\2\2\2\u0ca9\u0caf\5\u01e8\u00f5\2\u0caa\u0caf"+
"\5\u01ea\u00f6\2\u0cab\u0caf\7m\2\2\u0cac\u0caf\7n\2\2\u0cad\u0caf\7o"+
"\2\2\u0cae\u0ca9\3\2\2\2\u0cae\u0caa\3\2\2\2\u0cae\u0cab\3\2\2\2\u0cae"+
"\u0cac\3\2\2\2\u0cae\u0cad\3\2\2\2\u0caf\u01e7\3\2\2\2\u0cb0\u0cb3\7\u00a3"+
"\2\2\u0cb1\u0cb3\7\u00a0\2\2\u0cb2\u0cb0\3\2\2\2\u0cb2\u0cb1\3\2\2\2\u0cb2"+
"\u0cb3\3\2\2\2\u0cb3\u0cb4\3\2\2\2\u0cb4\u0cb5\5\u01e2\u00f2\2\u0cb5\u01e9"+
"\3\2\2\2\u0cb6\u0cb9\7\u00c4\2\2\u0cb7\u0cb9\7\u00c3\2\2\u0cb8\u0cb6\3"+
"\2\2\2\u0cb8\u0cb7\3\2\2\2\u0cb9\u01eb\3\2\2\2\u0cba\u0cbe\5\u01e6\u00f4"+
"\2\u0cbb\u0cbe\5\u01ee\u00f8\2\u0cbc\u0cbe\5\u01f0\u00f9\2\u0cbd\u0cba"+
"\3\2\2\2\u0cbd\u0cbb\3\2\2\2\u0cbd\u0cbc\3\2\2\2\u0cbe\u01ed\3\2\2\2\u0cbf"+
"\u0cc0\7\u0096\2\2\u0cc0\u0cc1\5\u01f4\u00fb\2\u0cc1\u0cc2\7\u0097\2\2"+
"\u0cc2\u01ef\3\2\2\2\u0cc3\u0cc5\7\u0094\2\2\u0cc4\u0cc6\5\u01f2\u00fa"+
"\2\u0cc5\u0cc4\3\2\2\2\u0cc5\u0cc6\3\2\2\2\u0cc6\u0cc7\3\2\2\2\u0cc7\u0cc8"+
"\7\u0095\2\2\u0cc8\u01f1\3\2\2\2\u0cc9\u0cce\5\u01ec\u00f7\2\u0cca\u0ccb"+
"\7\u0099\2\2\u0ccb\u0ccd\5\u01ec\u00f7\2\u0ccc\u0cca\3\2\2\2\u0ccd\u0cd0"+
"\3\2\2\2\u0cce\u0ccc\3\2\2\2\u0cce\u0ccf\3\2\2\2\u0ccf\u0cd2\3\2\2\2\u0cd0"+
"\u0cce\3\2\2\2\u0cd1\u0cd3\7\u0099\2\2\u0cd2\u0cd1\3\2\2\2\u0cd2\u0cd3"+
"\3\2\2\2\u0cd3\u01f3\3\2\2\2\u0cd4\u0cd9\5\u01f6\u00fc\2\u0cd5\u0cd6\7"+
"\u0099\2\2\u0cd6\u0cd8\5\u01f6\u00fc\2\u0cd7\u0cd5\3\2\2\2\u0cd8\u0cdb"+
"\3\2\2\2\u0cd9\u0cd7\3\2\2\2\u0cd9\u0cda\3\2\2\2\u0cda\u0cdd\3\2\2\2\u0cdb"+
"\u0cd9\3\2\2\2\u0cdc\u0cde\7\u0099\2\2\u0cdd\u0cdc\3\2\2\2\u0cdd\u0cde"+
"\3\2\2\2\u0cde\u01f5\3\2\2\2\u0cdf\u0ce2\5\u01ea\u00f6\2\u0ce0\u0ce2\5"+
"\u01c8\u00e5\2\u0ce1\u0cdf\3\2\2\2\u0ce1\u0ce0\3\2\2\2\u0ce2\u0ce3\3\2"+
"\2\2\u0ce3\u0ce4\7\u0098\2\2\u0ce4\u0ce5\5\u01ec\u00f7\2\u0ce5\u01f7\3"+
"\2\2\2\u01db\u01fa\u01fc\u0204\u0206\u0214\u0218\u021b\u021e\u0223\u0226"+
"\u022a\u0233\u023c\u0243\u0252\u0255\u025c\u0268\u0270\u0273\u0276\u027b"+
"\u028b\u028e\u0295\u0299\u029f\u02a2\u02a6\u02ab\u02af\u02b3\u02b8\u02bc"+
"\u02c5\u02c8\u02ca\u02cf\u02d3\u02d8\u02e2\u02e8\u02ec\u02f2\u02f6\u02fb"+
"\u02ff\u0305\u030a\u0313\u0318\u031b\u0322\u0327\u032f\u0335\u033b\u033f"+
"\u0343\u0346\u0349\u034d\u0351\u0356\u035a\u035f\u0363\u036a\u0370\u0377"+
"\u037b\u0382\u0387\u038d\u0397\u039f\u03a6\u03ac\u03b0\u03b3\u03ba\u03bf"+
"\u03c1\u03c7\u03cd\u03dc\u03e2\u03e5\u03ea\u03ed\u03ef\u03f3\u03f9\u03fc"+
"\u0401\u0407\u0412\u0419\u041c\u041f\u0423\u0425\u042b\u042e\u0435\u043d"+
"\u0440\u0442\u0449\u0450\u0456\u045a\u0461\u0466\u0469\u046e\u0477\u047b"+
"\u048b\u0493\u0499\u049e\u04a1\u04a4\u04a8\u04ab\u04b1\u04bc\u04c1\u04c4"+
"\u04d6\u04db\u04e3\u04ea\u04ee\u04f5\u0503\u0505\u050b\u051a\u051d\u0522"+
"\u052a\u052e\u0532\u0535\u053a\u053f\u0542\u0546\u054d\u0555\u055d\u0564"+
"\u056a\u056c\u0571\u0579\u057e\u0582\u0585\u058c\u0598\u05a6\u05ab\u05b3"+
"\u05b9\u05bc\u05c3\u05c9\u05cf\u05d6\u05dc\u05df\u05e2\u05e7\u05ef\u05fb"+
"\u05fe\u0607\u060d\u0611\u0614\u0617\u0621\u0627\u062a\u062f\u0632\u0636"+
"\u063c\u063f\u0645\u0652\u0657\u0659\u0662\u0665\u0668\u0670\u0679\u067c"+
"\u0684\u068a\u068e\u0691\u0698\u069e\u06a7\u06b4\u06bb\u06c4\u06c7\u06ca"+
"\u06d1\u06d7\u06dc\u06e2\u06e8\u06eb\u06f3\u06f9\u06fd\u0700\u0703\u070a"+
"\u070e\u0715\u0719\u071d\u0721\u0723\u0734\u0738\u073b\u073f\u0742\u074d"+
"\u0756\u075c\u075e\u0773\u077a\u0780\u0785\u078d\u0790\u0799\u07a2\u07a5"+
"\u07a7\u07aa\u07ae\u07b1\u07b4\u07be\u07cc\u07cf\u07da\u07dd\u07e3\u07ea"+
"\u07f2\u07fa\u0800\u0809\u080f\u0813\u0817\u0819\u081d\u0825\u082b\u082f"+
"\u0833\u0835\u0839\u083d\u0842\u084b\u084e\u0852\u085c\u0860\u0862\u086d"+
"\u0870\u0877\u087f\u088a\u0898\u08a5\u08a8\u08ac\u08b5\u08ba\u08bd\u08c1"+
"\u08c9\u08cf\u08d3\u08dd\u08e4\u08e9\u08ed\u08f3\u08f8\u08fc\u0904\u0907"+
"\u090b\u0910\u0918\u0921\u0929\u0931\u0939\u0948\u0952\u0956\u095d\u0961"+
"\u096d\u0989\u099a\u099e\u09a8\u09ab\u09b0\u09b5\u09b9\u09bd\u09c1\u09c8"+
"\u09d0\u09d4\u09d7\u09dc\u09df\u09e4\u09ea\u09f6\u09f9\u0a00\u0a04\u0a12"+
"\u0a1a\u0a23\u0a2b\u0a2f\u0a34\u0a3a\u0a3d\u0a3f\u0a48\u0a4e\u0a56\u0a5f"+
"\u0a65\u0a69\u0a72\u0a7e\u0a80\u0a84\u0a8a\u0a8f\u0a92\u0a95\u0a9b\u0aa0"+
"\u0aa4\u0aa8\u0aac\u0ab9\u0ac1\u0ac3\u0aca\u0ad4\u0ad9\u0adc\u0adf\u0ae2"+
"\u0aea\u0af1\u0af5\u0afc\u0b04\u0b0c\u0b11\u0b15\u0b1c\u0b1f\u0b26\u0b29"+
"\u0b30\u0b38\u0b45\u0b49\u0b51\u0b5c\u0b61\u0b67\u0b6c\u0b73\u0b7d\u0b85"+
"\u0b8c\u0b94\u0b99\u0b9d\u0ba0\u0ba6\u0baa\u0be1\u0be6\u0bea\u0bee\u0bf1"+
"\u0bf4\u0bf7\u0bfa\u0bfd\u0c00\u0c03\u0c07\u0c0a\u0c0d\u0c10\u0c13\u0c16"+
"\u0c19\u0c1d\u0c20\u0c23\u0c26\u0c29\u0c2c\u0c30\u0c33\u0c36\u0c39\u0c3c"+
"\u0c40\u0c43\u0c46\u0c49\u0c4d\u0c50\u0c53\u0c57\u0c5a\u0c5e\u0c61\u0c66"+
"\u0c6d\u0c74\u0c7b\u0c82\u0c89\u0c90\u0c97\u0c9e\u0ca7\u0cae\u0cb2\u0cb8"+
"\u0cbd\u0cc5\u0cce\u0cd2\u0cd9\u0cdd\u0ce1";
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);
}
}
}