Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.espertech.esper.compiler.internal.generated.EsperEPL2GrammarParser Maven / Gradle / Ivy
// Generated from EsperEPL2Grammar.g by ANTLR 4.7.1
/*
***************************************************************************************
* Copyright (C) 2006 EsperTech, Inc. All rights reserved. *
* http://www.espertech.com/esper *
* http://www.espertech.com *
* ---------------------------------------------------------------------------------- *
* The software in this package is published under the terms of the GPL license *
* a copy of which has been included with this distribution in the license.txt file. *
***************************************************************************************
*/
package com.espertech.esper.compiler.internal.generated;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class EsperEPL2GrammarParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", 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_startEPLExpressionRule = 0, RULE_startEventPropertyRule = 1, RULE_startJsonValueRule = 2,
RULE_expressionDecl = 3, RULE_expressionDialect = 4, RULE_expressionDef = 5,
RULE_expressionLambdaDecl = 6, RULE_expressionTypeAnno = 7, RULE_annotationEnum = 8,
RULE_elementValuePairsEnum = 9, RULE_elementValuePairEnum = 10, RULE_elementValueEnum = 11,
RULE_elementValueArrayEnum = 12, RULE_eplExpression = 13, RULE_contextExpr = 14,
RULE_selectExpr = 15, RULE_onExpr = 16, RULE_onStreamExpr = 17, RULE_updateExpr = 18,
RULE_updateDetails = 19, RULE_onMergeExpr = 20, RULE_mergeItem = 21, RULE_mergeMatched = 22,
RULE_mergeMatchedItem = 23, RULE_onMergeDirectInsert = 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_createColumnList = 47, RULE_createColumnListElement = 48, RULE_createSelectionList = 49,
RULE_createSelectionListElement = 50, RULE_createSchemaExpr = 51, RULE_createSchemaDef = 52,
RULE_fafDelete = 53, RULE_fafUpdate = 54, RULE_fafInsert = 55, RULE_createDataflow = 56,
RULE_gopList = 57, RULE_gop = 58, RULE_gopParams = 59, RULE_gopParamsItemList = 60,
RULE_gopParamsItem = 61, RULE_gopParamsItemMany = 62, RULE_gopParamsItemAs = 63,
RULE_gopOut = 64, RULE_gopOutItem = 65, RULE_gopOutTypeList = 66, RULE_gopOutTypeParam = 67,
RULE_gopOutTypeItem = 68, RULE_gopDetail = 69, RULE_gopConfig = 70, RULE_createContextExpr = 71,
RULE_createExpressionExpr = 72, RULE_createContextDetail = 73, RULE_contextContextNested = 74,
RULE_createContextChoice = 75, RULE_createContextDistinct = 76, RULE_createContextRangePoint = 77,
RULE_createContextFilter = 78, RULE_createContextPartitionItem = 79, RULE_createContextCoalesceItem = 80,
RULE_createContextGroupItem = 81, RULE_createContextPartitionInit = 82,
RULE_createContextPartitionTerm = 83, RULE_createSchemaQual = 84, RULE_variantList = 85,
RULE_variantListElement = 86, RULE_intoTableExpr = 87, RULE_insertIntoExpr = 88,
RULE_columnList = 89, RULE_fromClause = 90, RULE_regularJoin = 91, RULE_outerJoinList = 92,
RULE_outerJoin = 93, RULE_outerJoinIdent = 94, RULE_outerJoinIdentPair = 95,
RULE_whereClause = 96, RULE_selectClause = 97, RULE_selectionList = 98,
RULE_selectionListElement = 99, RULE_selectionListElementExpr = 100, RULE_selectionListElementAnno = 101,
RULE_streamSelector = 102, RULE_streamExpression = 103, RULE_forExpr = 104,
RULE_patternInclusionExpression = 105, RULE_databaseJoinExpression = 106,
RULE_methodJoinExpression = 107, RULE_viewExpressions = 108, RULE_viewExpressionWNamespace = 109,
RULE_viewExpressionOptNamespace = 110, RULE_viewWParameters = 111, RULE_groupByListExpr = 112,
RULE_groupByListChoice = 113, RULE_groupByCubeOrRollup = 114, RULE_groupByGroupingSets = 115,
RULE_groupBySetsChoice = 116, RULE_groupByCombinableExpr = 117, RULE_orderByListExpr = 118,
RULE_orderByListElement = 119, RULE_havingClause = 120, RULE_outputLimit = 121,
RULE_outputLimitAndTerm = 122, RULE_outputLimitAfter = 123, RULE_rowLimit = 124,
RULE_crontabLimitParameterSetList = 125, RULE_crontabLimitParameterSet = 126,
RULE_whenClause = 127, RULE_elseClause = 128, RULE_matchRecog = 129, RULE_matchRecogPartitionBy = 130,
RULE_matchRecogMeasures = 131, RULE_matchRecogMeasureItem = 132, RULE_matchRecogMatchesSelection = 133,
RULE_matchRecogPattern = 134, RULE_matchRecogMatchesAfterSkip = 135, RULE_matchRecogMatchesInterval = 136,
RULE_matchRecogPatternAlteration = 137, RULE_matchRecogPatternConcat = 138,
RULE_matchRecogPatternUnary = 139, RULE_matchRecogPatternNested = 140,
RULE_matchRecogPatternPermute = 141, RULE_matchRecogPatternAtom = 142,
RULE_matchRecogPatternRepeat = 143, RULE_matchRecogDefine = 144, RULE_matchRecogDefineItem = 145,
RULE_expression = 146, RULE_caseExpression = 147, RULE_evalOrExpression = 148,
RULE_evalAndExpression = 149, RULE_bitWiseExpression = 150, RULE_negatedExpression = 151,
RULE_evalEqualsExpression = 152, RULE_evalRelationalExpression = 153,
RULE_inSubSelectQuery = 154, RULE_concatenationExpr = 155, RULE_additiveExpression = 156,
RULE_multiplyExpression = 157, RULE_unaryExpression = 158, RULE_unaryMinus = 159,
RULE_substitutionCanChain = 160, RULE_chainedFunction = 161, RULE_newAssign = 162,
RULE_rowSubSelectExpression = 163, RULE_subSelectGroupExpression = 164,
RULE_existsSubSelectExpression = 165, RULE_subQueryExpr = 166, RULE_subSelectFilterExpr = 167,
RULE_arrayExpression = 168, RULE_builtinFunc = 169, RULE_firstLastWindowAggregation = 170,
RULE_eventPropertyOrLibFunction = 171, RULE_libFunction = 172, RULE_libFunctionWithClass = 173,
RULE_libFunctionNoClass = 174, RULE_funcIdentTop = 175, RULE_funcIdentInner = 176,
RULE_funcIdentChained = 177, RULE_libFunctionArgs = 178, RULE_libFunctionArgItem = 179,
RULE_betweenList = 180, RULE_patternExpression = 181, RULE_followedByExpression = 182,
RULE_followedByRepeat = 183, RULE_orExpression = 184, RULE_andExpression = 185,
RULE_matchUntilExpression = 186, RULE_qualifyExpression = 187, RULE_guardPostFix = 188,
RULE_distinctExpressionList = 189, RULE_distinctExpressionAtom = 190,
RULE_atomicExpression = 191, RULE_observerExpression = 192, RULE_guardWhereExpression = 193,
RULE_guardWhileExpression = 194, RULE_matchUntilRange = 195, RULE_eventFilterExpression = 196,
RULE_propertyExpression = 197, RULE_propertyExpressionAtomic = 198, RULE_propertyExpressionSelect = 199,
RULE_propertySelectionList = 200, RULE_propertySelectionListElement = 201,
RULE_propertyStreamSelector = 202, RULE_typeExpressionAnnotation = 203,
RULE_patternFilterExpression = 204, RULE_patternFilterAnnotation = 205,
RULE_classIdentifierWithDimensions = 206, RULE_dimensions = 207, RULE_classIdentifier = 208,
RULE_expressionListWithNamed = 209, RULE_expressionListWithNamedWithTime = 210,
RULE_expressionWithNamed = 211, RULE_expressionWithNamedWithTime = 212,
RULE_expressionNamedParameter = 213, RULE_expressionNamedParameterWithTime = 214,
RULE_expressionList = 215, RULE_expressionWithTimeList = 216, RULE_expressionWithTime = 217,
RULE_expressionWithTimeInclLast = 218, RULE_expressionQualifyable = 219,
RULE_lastWeekdayOperand = 220, RULE_lastOperand = 221, RULE_frequencyOperand = 222,
RULE_rangeOperand = 223, RULE_lastOperator = 224, RULE_weekDayOperator = 225,
RULE_numericParameterList = 226, RULE_numericListParameter = 227, RULE_eventProperty = 228,
RULE_eventPropertyAtomic = 229, RULE_eventPropertyIdent = 230, RULE_identOrTicked = 231,
RULE_keywordAllowedIdent = 232, RULE_escapableStr = 233, RULE_escapableIdent = 234,
RULE_timePeriod = 235, RULE_yearPart = 236, RULE_monthPart = 237, RULE_weekPart = 238,
RULE_dayPart = 239, RULE_hourPart = 240, RULE_minutePart = 241, RULE_secondPart = 242,
RULE_millisecondPart = 243, RULE_microsecondPart = 244, RULE_number = 245,
RULE_substitution = 246, RULE_substitutionSlashIdent = 247, RULE_constant = 248,
RULE_numberconstant = 249, RULE_stringconstant = 250, RULE_jsonvalue = 251,
RULE_jsonobject = 252, RULE_jsonarray = 253, RULE_jsonelements = 254,
RULE_jsonmembers = 255, RULE_jsonpair = 256;
public static final String[] ruleNames = {
"startEPLExpressionRule", "startEventPropertyRule", "startJsonValueRule",
"expressionDecl", "expressionDialect", "expressionDef", "expressionLambdaDecl",
"expressionTypeAnno", "annotationEnum", "elementValuePairsEnum", "elementValuePairEnum",
"elementValueEnum", "elementValueArrayEnum", "eplExpression", "contextExpr",
"selectExpr", "onExpr", "onStreamExpr", "updateExpr", "updateDetails",
"onMergeExpr", "mergeItem", "mergeMatched", "mergeMatchedItem", "onMergeDirectInsert",
"mergeUnmatched", "mergeUnmatchedItem", "mergeInsert", "onSelectExpr",
"onUpdateExpr", "onSelectInsertExpr", "onSelectInsertFromClause", "outputClauseInsert",
"onDeleteExpr", "onSetExpr", "onSetAssignmentList", "onSetAssignment",
"onExprFrom", "createWindowExpr", "createWindowExprModelAfter", "createIndexExpr",
"createIndexColumnList", "createIndexColumn", "createVariableExpr", "createTableExpr",
"createTableColumnList", "createTableColumn", "createColumnList", "createColumnListElement",
"createSelectionList", "createSelectionListElement", "createSchemaExpr",
"createSchemaDef", "fafDelete", "fafUpdate", "fafInsert", "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",
"createContextPartitionInit", "createContextPartitionTerm", "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", "crontabLimitParameterSetList",
"crontabLimitParameterSet", "whenClause", "elseClause", "matchRecog",
"matchRecogPartitionBy", "matchRecogMeasures", "matchRecogMeasureItem",
"matchRecogMatchesSelection", "matchRecogPattern", "matchRecogMatchesAfterSkip",
"matchRecogMatchesInterval", "matchRecogPatternAlteration", "matchRecogPatternConcat",
"matchRecogPatternUnary", "matchRecogPatternNested", "matchRecogPatternPermute",
"matchRecogPatternAtom", "matchRecogPatternRepeat", "matchRecogDefine",
"matchRecogDefineItem", "expression", "caseExpression", "evalOrExpression",
"evalAndExpression", "bitWiseExpression", "negatedExpression", "evalEqualsExpression",
"evalRelationalExpression", "inSubSelectQuery", "concatenationExpr", "additiveExpression",
"multiplyExpression", "unaryExpression", "unaryMinus", "substitutionCanChain",
"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", "classIdentifierWithDimensions", "dimensions",
"classIdentifier", "expressionListWithNamed", "expressionListWithNamedWithTime",
"expressionWithNamed", "expressionWithNamedWithTime", "expressionNamedParameter",
"expressionNamedParameterWithTime", "expressionList", "expressionWithTimeList",
"expressionWithTime", "expressionWithTimeInclLast", "expressionQualifyable",
"lastWeekdayOperand", "lastOperand", "frequencyOperand", "rangeOperand",
"lastOperator", "weekDayOperator", "numericParameterList", "numericListParameter",
"eventProperty", "eventPropertyAtomic", "eventPropertyIdent", "identOrTicked",
"keywordAllowedIdent", "escapableStr", "escapableIdent", "timePeriod",
"yearPart", "monthPart", "weekPart", "dayPart", "hourPart", "minutePart",
"secondPart", "millisecondPart", "microsecondPart", "number", "substitution",
"substitutionSlashIdent", "constant", "numberconstant", "stringconstant",
"jsonvalue", "jsonobject", "jsonarray", "jsonelements", "jsonmembers",
"jsonpair"
};
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] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "EsperEPL2Grammar.g"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
// provide nice error messages
private java.util.Stack paraphrases = new java.util.Stack();
// static information initialized once
private static java.util.Map lexerTokenParaphases = new java.util.HashMap();
private static java.util.Map parserTokenParaphases = new java.util.HashMap();
private static java.util.Set parserKeywordSet = new java.util.HashSet();
private static java.util.Set afterScriptTokens = new java.util.HashSet();
public java.util.Stack getParaphrases() {
return paraphrases;
}
public java.util.Set getKeywords() {
getParserTokenParaphrases();
return parserKeywordSet;
}
public synchronized static java.util.Map getLexerTokenParaphrases() {
if (lexerTokenParaphases.size() == 0) {
lexerTokenParaphases.put(IDENT, "an identifier");
lexerTokenParaphases.put(FOLLOWED_BY, "an followed-by '->'");
lexerTokenParaphases.put(EQUALS, "an equals '='");
lexerTokenParaphases.put(SQL_NE, "a sql-style not equals '<>'");
lexerTokenParaphases.put(QUESTION, "a questionmark '?'");
lexerTokenParaphases.put(LPAREN, "an opening parenthesis '('");
lexerTokenParaphases.put(RPAREN, "a closing parenthesis ')'");
lexerTokenParaphases.put(LBRACK, "a left angle bracket '['");
lexerTokenParaphases.put(RBRACK, "a right angle bracket ']'");
lexerTokenParaphases.put(LCURLY, "a left curly bracket '{'");
lexerTokenParaphases.put(RCURLY, "a right curly bracket '}'");
lexerTokenParaphases.put(COLON, "a colon ':'");
lexerTokenParaphases.put(COMMA, "a comma ','");
lexerTokenParaphases.put(EQUAL, "an equals compare '=='");
lexerTokenParaphases.put(LNOT, "a not '!'");
lexerTokenParaphases.put(BNOT, "a binary not '~'");
lexerTokenParaphases.put(NOT_EQUAL, "a not equals '!='");
lexerTokenParaphases.put(DIV, "a division operator '\'");
lexerTokenParaphases.put(DIV_ASSIGN, "a division assign '/='");
lexerTokenParaphases.put(PLUS, "a plus operator '+'");
lexerTokenParaphases.put(PLUS_ASSIGN, "a plus assign '+='");
lexerTokenParaphases.put(INC, "an increment operator '++'");
lexerTokenParaphases.put(MINUS, "a minus '-'");
lexerTokenParaphases.put(MINUS_ASSIGN, "a minus assign '-='");
lexerTokenParaphases.put(DEC, "a decrement operator '--'");
lexerTokenParaphases.put(STAR, "a star '*'");
lexerTokenParaphases.put(STAR_ASSIGN, "a star assign '*='");
lexerTokenParaphases.put(MOD, "a modulo");
lexerTokenParaphases.put(MOD_ASSIGN, "a modulo assign");
lexerTokenParaphases.put(GE, "a greater equals '>='");
lexerTokenParaphases.put(GT, "a greater then '>'");
lexerTokenParaphases.put(LE, "a less equals '<='");
lexerTokenParaphases.put(LT, "a lesser then '<'");
lexerTokenParaphases.put(BXOR, "a binary xor '^'");
lexerTokenParaphases.put(BXOR_ASSIGN, "a binary xor assign '^='");
lexerTokenParaphases.put(BOR, "a binary or '|'");
lexerTokenParaphases.put(BOR_ASSIGN, "a binary or assign '|='");
lexerTokenParaphases.put(LOR, "a logical or '||'");
lexerTokenParaphases.put(BAND, "a binary and '&'");
lexerTokenParaphases.put(BAND_ASSIGN, "a binary and assign '&='");
lexerTokenParaphases.put(LAND, "a logical and '&&'");
lexerTokenParaphases.put(SEMI, "a semicolon ';'");
lexerTokenParaphases.put(DOT, "a dot '.'");
}
return lexerTokenParaphases;
}
public synchronized static java.util.Map getParserTokenParaphrases() {
if (parserTokenParaphases.size() == 0) {
parserTokenParaphases.put(CREATE, "'create'");
parserTokenParaphases.put(WINDOW, "'window'");
parserTokenParaphases.put(IN_SET, "'in'");
parserTokenParaphases.put(BETWEEN, "'between'");
parserTokenParaphases.put(LIKE, "'like'");
parserTokenParaphases.put(REGEXP, "'regexp'");
parserTokenParaphases.put(ESCAPE, "'escape'");
parserTokenParaphases.put(OR_EXPR, "'or'");
parserTokenParaphases.put(AND_EXPR, "'and'");
parserTokenParaphases.put(NOT_EXPR, "'not'");
parserTokenParaphases.put(EVERY_EXPR, "'every'");
parserTokenParaphases.put(EVERY_DISTINCT_EXPR, "'every-distinct'");
parserTokenParaphases.put(WHERE, "'where'");
parserTokenParaphases.put(AS, "'as'");
parserTokenParaphases.put(SUM, "'sum'");
parserTokenParaphases.put(AVG, "'avg'");
parserTokenParaphases.put(MAX, "'max'");
parserTokenParaphases.put(MIN, "'min'");
parserTokenParaphases.put(COALESCE, "'coalesce'");
parserTokenParaphases.put(MEDIAN, "'median'");
parserTokenParaphases.put(STDDEV, "'stddev'");
parserTokenParaphases.put(AVEDEV, "'avedev'");
parserTokenParaphases.put(COUNT, "'count'");
parserTokenParaphases.put(SELECT, "'select'");
parserTokenParaphases.put(CASE, "'case'");
parserTokenParaphases.put(ELSE, "'else'");
parserTokenParaphases.put(WHEN, "'when'");
parserTokenParaphases.put(THEN, "'then'");
parserTokenParaphases.put(END, "'end'");
parserTokenParaphases.put(FROM, "'from'");
parserTokenParaphases.put(OUTER, "'outer'");
parserTokenParaphases.put(INNER, "'inner'");
parserTokenParaphases.put(JOIN, "'join'");
parserTokenParaphases.put(LEFT, "'left'");
parserTokenParaphases.put(RIGHT, "'right'");
parserTokenParaphases.put(FULL, "'full'");
parserTokenParaphases.put(ON, "'on'");
parserTokenParaphases.put(IS, "'is'");
parserTokenParaphases.put(BY, "'by'");
parserTokenParaphases.put(GROUP, "'group'");
parserTokenParaphases.put(HAVING, "'having'");
parserTokenParaphases.put(ALL, "'all'");
parserTokenParaphases.put(ANY, "'any'");
parserTokenParaphases.put(SOME, "'some'");
parserTokenParaphases.put(OUTPUT, "'output'");
parserTokenParaphases.put(EVENTS, "'events'");
parserTokenParaphases.put(FIRST, "'first'");
parserTokenParaphases.put(LAST, "'last'");
parserTokenParaphases.put(INSERT, "'insert'");
parserTokenParaphases.put(INTO, "'into'");
parserTokenParaphases.put(ORDER, "'order'");
parserTokenParaphases.put(ASC, "'asc'");
parserTokenParaphases.put(DESC, "'desc'");
parserTokenParaphases.put(RSTREAM, "'rstream'");
parserTokenParaphases.put(ISTREAM, "'istream'");
parserTokenParaphases.put(IRSTREAM, "'irstream'");
parserTokenParaphases.put(SCHEMA, "'schema'");
parserTokenParaphases.put(UNIDIRECTIONAL, "'unidirectional'");
parserTokenParaphases.put(RETAINUNION, "'retain-union'");
parserTokenParaphases.put(RETAININTERSECTION, "'retain-intersection'");
parserTokenParaphases.put(PATTERN, "'pattern'");
parserTokenParaphases.put(SQL, "'sql'");
parserTokenParaphases.put(METADATASQL, "'metadatasql'");
parserTokenParaphases.put(PREVIOUS, "'prev'");
parserTokenParaphases.put(PREVIOUSTAIL, "'prevtail'");
parserTokenParaphases.put(PREVIOUSCOUNT, "'prevcount'");
parserTokenParaphases.put(PREVIOUSWINDOW, "'prevwindow'");
parserTokenParaphases.put(PRIOR, "'prior'");
parserTokenParaphases.put(EXISTS, "'exists'");
parserTokenParaphases.put(WEEKDAY, "'weekday'");
parserTokenParaphases.put(LW, "'lastweekday'");
parserTokenParaphases.put(INSTANCEOF, "'instanceof'");
parserTokenParaphases.put(TYPEOF, "'typeof'");
parserTokenParaphases.put(CAST, "'cast'");
parserTokenParaphases.put(CURRENT_TIMESTAMP, "'current_timestamp'");
parserTokenParaphases.put(DELETE, "'delete'");
parserTokenParaphases.put(DISTINCT, "'distinct'");
parserTokenParaphases.put(SNAPSHOT, "'snapshot'");
parserTokenParaphases.put(SET, "'set'");
parserTokenParaphases.put(VARIABLE, "'variable'");
parserTokenParaphases.put(TABLE, "'table'");
parserTokenParaphases.put(INDEX, "'index'");
parserTokenParaphases.put(UNTIL, "'until'");
parserTokenParaphases.put(AT, "'at'");
parserTokenParaphases.put(TIMEPERIOD_YEAR, "'year'");
parserTokenParaphases.put(TIMEPERIOD_YEARS, "'years'");
parserTokenParaphases.put(TIMEPERIOD_MONTH, "'month'");
parserTokenParaphases.put(TIMEPERIOD_MONTHS, "'months'");
parserTokenParaphases.put(TIMEPERIOD_WEEK, "'week'");
parserTokenParaphases.put(TIMEPERIOD_WEEKS, "'weeks'");
parserTokenParaphases.put(TIMEPERIOD_DAY, "'day'");
parserTokenParaphases.put(TIMEPERIOD_DAYS, "'days'");
parserTokenParaphases.put(TIMEPERIOD_HOUR, "'hour'");
parserTokenParaphases.put(TIMEPERIOD_HOURS, "'hours'");
parserTokenParaphases.put(TIMEPERIOD_MINUTE, "'minute'");
parserTokenParaphases.put(TIMEPERIOD_MINUTES, "'minutes'");
parserTokenParaphases.put(TIMEPERIOD_SEC, "'sec'");
parserTokenParaphases.put(TIMEPERIOD_SECOND, "'second'");
parserTokenParaphases.put(TIMEPERIOD_SECONDS, "'seconds'");
parserTokenParaphases.put(TIMEPERIOD_MILLISEC, "'msec'");
parserTokenParaphases.put(TIMEPERIOD_MILLISECOND, "'millisecond'");
parserTokenParaphases.put(TIMEPERIOD_MILLISECONDS, "'milliseconds'");
parserTokenParaphases.put(TIMEPERIOD_MICROSEC, "'usec'");
parserTokenParaphases.put(TIMEPERIOD_MICROSECOND, "'microsecond'");
parserTokenParaphases.put(TIMEPERIOD_MICROSECONDS, "'microseconds'");
parserTokenParaphases.put(BOOLEAN_TRUE, "'true'");
parserTokenParaphases.put(BOOLEAN_FALSE, "'false'");
parserTokenParaphases.put(VALUE_NULL, "'null'");
parserTokenParaphases.put(ROW_LIMIT_EXPR, "'limit'");
parserTokenParaphases.put(OFFSET, "'offset'");
parserTokenParaphases.put(UPDATE, "'update'");
parserTokenParaphases.put(MATCH_RECOGNIZE, "'match_recognize'");
parserTokenParaphases.put(MEASURES, "'measures'");
parserTokenParaphases.put(DEFINE, "'define'");
parserTokenParaphases.put(PARTITION, "'partition'");
parserTokenParaphases.put(MATCHES, "'matches'");
parserTokenParaphases.put(AFTER, "'after'");
parserTokenParaphases.put(FOR, "'for'");
parserTokenParaphases.put(WHILE, "'while'");
parserTokenParaphases.put(MERGE, "'merge'");
parserTokenParaphases.put(MATCHED, "'matched'");
parserTokenParaphases.put(CONTEXT, "'context'");
parserTokenParaphases.put(START, "'start'");
parserTokenParaphases.put(END, "'end'");
parserTokenParaphases.put(INITIATED, "'initiated'");
parserTokenParaphases.put(TERMINATED, "'terminated'");
parserTokenParaphases.put(USING, "'using'");
parserTokenParaphases.put(EXPRESSIONDECL, "'expression'");
parserTokenParaphases.put(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(parserTokenParaphases.values());
}
return parserTokenParaphases;
}
public synchronized static java.util.Set getAfterScriptTokens() {
if (afterScriptTokens.size() == 0) {
afterScriptTokens.add(CREATE);
afterScriptTokens.add(EXPRESSIONDECL);
afterScriptTokens.add(SELECT);
afterScriptTokens.add(INSERT);
afterScriptTokens.add(ON);
afterScriptTokens.add(DELETE);
afterScriptTokens.add(UPDATE);
afterScriptTokens.add(ATCHAR);
}
return afterScriptTokens;
}
public EsperEPL2GrammarParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class StartEPLExpressionRuleContext extends ParserRuleContext {
public EplExpressionContext eplExpression() {
return getRuleContext(EplExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public List expressionDecl() {
return getRuleContexts(ExpressionDeclContext.class);
}
public ExpressionDeclContext expressionDecl(int i) {
return getRuleContext(ExpressionDeclContext.class,i);
}
public StartEPLExpressionRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startEPLExpressionRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStartEPLExpressionRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStartEPLExpressionRule(this);
}
}
public final StartEPLExpressionRuleContext startEPLExpressionRule() throws RecognitionException {
StartEPLExpressionRuleContext _localctx = new StartEPLExpressionRuleContext(_ctx, getState());
enterRule(_localctx, 0, RULE_startEPLExpressionRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==EXPRESSIONDECL || _la==ATCHAR) {
{
setState(516);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(514);
annotationEnum();
}
break;
case EXPRESSIONDECL:
{
setState(515);
expressionDecl();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(520);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(521);
eplExpression();
setState(522);
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, 2, RULE_startEventPropertyRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(524);
eventProperty();
setState(525);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StartJsonValueRuleContext extends ParserRuleContext {
public JsonvalueContext jsonvalue() {
return getRuleContext(JsonvalueContext.class,0);
}
public TerminalNode EOF() { return getToken(EsperEPL2GrammarParser.EOF, 0); }
public StartJsonValueRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startJsonValueRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStartJsonValueRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStartJsonValueRule(this);
}
}
public final StartJsonValueRuleContext startJsonValueRule() throws RecognitionException {
StartJsonValueRuleContext _localctx = new StartJsonValueRuleContext(_ctx, getState());
enterRule(_localctx, 4, RULE_startJsonValueRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(527);
jsonvalue();
setState(528);
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 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, 6, RULE_expressionDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(530);
match(EXPRESSIONDECL);
setState(532);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(531);
classIdentifier();
}
break;
}
setState(536);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(534);
((ExpressionDeclContext)_localctx).array = match(LBRACK);
setState(535);
match(RBRACK);
}
}
setState(539);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(538);
typeExpressionAnnotation();
}
}
setState(542);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(541);
expressionDialect();
}
break;
}
setState(544);
((ExpressionDeclContext)_localctx).name = match(IDENT);
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(545);
match(LPAREN);
setState(547);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(546);
columnList();
}
}
setState(549);
match(RPAREN);
}
}
setState(554);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(552);
((ExpressionDeclContext)_localctx).alias = match(IDENT);
setState(553);
match(FOR);
}
}
setState(556);
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, 8, RULE_expressionDialect);
try {
enterOuterAlt(_localctx, 1);
{
setState(558);
((ExpressionDialectContext)_localctx).d = match(IDENT);
setState(559);
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, 10, RULE_expressionDef);
try {
setState(572);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURLY:
enterOuterAlt(_localctx, 1);
{
setState(561);
match(LCURLY);
setState(563);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(562);
expressionLambdaDecl();
}
break;
}
setState(565);
expression();
setState(566);
match(RCURLY);
}
break;
case LBRACK:
enterOuterAlt(_localctx, 2);
{
setState(568);
match(LBRACK);
setState(569);
stringconstant();
setState(570);
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, 12, RULE_expressionLambdaDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(579);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(574);
((ExpressionLambdaDeclContext)_localctx).i = match(IDENT);
}
break;
case LPAREN:
{
{
setState(575);
match(LPAREN);
setState(576);
columnList();
setState(577);
match(RPAREN);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(581);
_la = _input.LA(1);
if ( !(_la==FOLLOWED_BY || _la==GOES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionTypeAnnoContext extends ParserRuleContext {
public Token n;
public Token v;
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionTypeAnnoContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionTypeAnno; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionTypeAnno(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionTypeAnno(this);
}
}
public final ExpressionTypeAnnoContext expressionTypeAnno() throws RecognitionException {
ExpressionTypeAnnoContext _localctx = new ExpressionTypeAnnoContext(_ctx, getState());
enterRule(_localctx, 14, RULE_expressionTypeAnno);
try {
enterOuterAlt(_localctx, 1);
{
setState(583);
match(ATCHAR);
setState(584);
((ExpressionTypeAnnoContext)_localctx).n = match(IDENT);
{
setState(585);
match(LPAREN);
setState(586);
((ExpressionTypeAnnoContext)_localctx).v = match(IDENT);
setState(587);
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, 16, RULE_annotationEnum);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(589);
match(ATCHAR);
setState(590);
classIdentifier();
setState(597);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(591);
match(LPAREN);
setState(594);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(592);
elementValuePairsEnum();
}
break;
case 2:
{
setState(593);
elementValueEnum();
}
break;
}
setState(596);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairsEnumContext extends ParserRuleContext {
public List elementValuePairEnum() {
return getRuleContexts(ElementValuePairEnumContext.class);
}
public ElementValuePairEnumContext elementValuePairEnum(int i) {
return getRuleContext(ElementValuePairEnumContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ElementValuePairsEnumContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePairsEnum; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterElementValuePairsEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitElementValuePairsEnum(this);
}
}
public final ElementValuePairsEnumContext elementValuePairsEnum() throws RecognitionException {
ElementValuePairsEnumContext _localctx = new ElementValuePairsEnumContext(_ctx, getState());
enterRule(_localctx, 18, RULE_elementValuePairsEnum);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(599);
elementValuePairEnum();
setState(604);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(600);
match(COMMA);
setState(601);
elementValuePairEnum();
}
}
setState(606);
_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, 20, RULE_elementValuePairEnum);
try {
enterOuterAlt(_localctx, 1);
{
setState(607);
keywordAllowedIdent();
setState(608);
match(EQUALS);
setState(609);
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, 22, RULE_elementValueEnum);
try {
setState(616);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(611);
annotationEnum();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(612);
elementValueArrayEnum();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(613);
constant();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(614);
((ElementValueEnumContext)_localctx).v = match(IDENT);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(615);
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 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, 24, RULE_elementValueArrayEnum);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(618);
match(LCURLY);
setState(627);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << (EVENTS - 47)) | (1L << (BOOLEAN_TRUE - 47)) | (1L << (BOOLEAN_FALSE - 47)) | (1L << (VALUE_NULL - 47)))) != 0) || ((((_la - 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(619);
elementValueEnum();
setState(624);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(620);
match(COMMA);
setState(621);
elementValueEnum();
}
}
}
setState(626);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
}
}
}
setState(630);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(629);
match(COMMA);
}
}
setState(632);
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, 26, RULE_eplExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(635);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONTEXT) {
{
setState(634);
contextExpr();
}
}
setState(651);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(637);
selectExpr();
}
break;
case 2:
{
setState(638);
createWindowExpr();
}
break;
case 3:
{
setState(639);
createIndexExpr();
}
break;
case 4:
{
setState(640);
createVariableExpr();
}
break;
case 5:
{
setState(641);
createTableExpr();
}
break;
case 6:
{
setState(642);
createSchemaExpr();
}
break;
case 7:
{
setState(643);
createContextExpr();
}
break;
case 8:
{
setState(644);
createExpressionExpr();
}
break;
case 9:
{
setState(645);
onExpr();
}
break;
case 10:
{
setState(646);
updateExpr();
}
break;
case 11:
{
setState(647);
createDataflow();
}
break;
case 12:
{
setState(648);
fafDelete();
}
break;
case 13:
{
setState(649);
fafUpdate();
}
break;
case 14:
{
setState(650);
fafInsert();
}
break;
}
setState(654);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(653);
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, 28, RULE_contextExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(656);
match(CONTEXT);
setState(657);
((ContextExprContext)_localctx).i = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectExprContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public IntoTableExprContext intoTableExpr() {
return getRuleContext(IntoTableExprContext.class,0);
}
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public InsertIntoExprContext insertIntoExpr() {
return getRuleContext(InsertIntoExprContext.class,0);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public MatchRecogContext matchRecog() {
return getRuleContext(MatchRecogContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode GROUP() { return getToken(EsperEPL2GrammarParser.GROUP, 0); }
public List BY() { return getTokens(EsperEPL2GrammarParser.BY); }
public TerminalNode BY(int i) {
return getToken(EsperEPL2GrammarParser.BY, i);
}
public GroupByListExprContext groupByListExpr() {
return getRuleContext(GroupByListExprContext.class,0);
}
public TerminalNode HAVING() { return getToken(EsperEPL2GrammarParser.HAVING, 0); }
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public TerminalNode OUTPUT() { return getToken(EsperEPL2GrammarParser.OUTPUT, 0); }
public OutputLimitContext outputLimit() {
return getRuleContext(OutputLimitContext.class,0);
}
public TerminalNode ORDER() { return getToken(EsperEPL2GrammarParser.ORDER, 0); }
public OrderByListExprContext orderByListExpr() {
return getRuleContext(OrderByListExprContext.class,0);
}
public TerminalNode ROW_LIMIT_EXPR() { return getToken(EsperEPL2GrammarParser.ROW_LIMIT_EXPR, 0); }
public RowLimitContext rowLimit() {
return getRuleContext(RowLimitContext.class,0);
}
public SelectExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectExpr(this);
}
}
public final SelectExprContext selectExpr() throws RecognitionException {
SelectExprContext _localctx = new SelectExprContext(_ctx, getState());
enterRule(_localctx, 30, RULE_selectExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(661);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(659);
match(INTO);
setState(660);
intoTableExpr();
}
}
setState(665);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(663);
match(INSERT);
setState(664);
insertIntoExpr();
}
}
setState(667);
match(SELECT);
setState(668);
selectClause();
setState(671);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(669);
match(FROM);
setState(670);
fromClause();
}
}
setState(674);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MATCH_RECOGNIZE) {
{
setState(673);
matchRecog();
}
}
setState(678);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(676);
match(WHERE);
setState(677);
whereClause();
}
}
setState(683);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(680);
match(GROUP);
setState(681);
match(BY);
setState(682);
groupByListExpr();
}
}
setState(687);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(685);
match(HAVING);
setState(686);
havingClause();
}
}
setState(691);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTPUT) {
{
setState(689);
match(OUTPUT);
setState(690);
outputLimit();
}
}
setState(696);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(693);
match(ORDER);
setState(694);
match(BY);
setState(695);
orderByListExpr();
}
}
setState(700);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW_LIMIT_EXPR) {
{
setState(698);
match(ROW_LIMIT_EXPR);
setState(699);
rowLimit();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnExprContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(EsperEPL2GrammarParser.ON, 0); }
public OnStreamExprContext onStreamExpr() {
return getRuleContext(OnStreamExprContext.class,0);
}
public OnDeleteExprContext onDeleteExpr() {
return getRuleContext(OnDeleteExprContext.class,0);
}
public OnSelectExprContext onSelectExpr() {
return getRuleContext(OnSelectExprContext.class,0);
}
public OnSetExprContext onSetExpr() {
return getRuleContext(OnSetExprContext.class,0);
}
public OnUpdateExprContext onUpdateExpr() {
return getRuleContext(OnUpdateExprContext.class,0);
}
public OnMergeExprContext onMergeExpr() {
return getRuleContext(OnMergeExprContext.class,0);
}
public List onSelectInsertExpr() {
return getRuleContexts(OnSelectInsertExprContext.class);
}
public OnSelectInsertExprContext onSelectInsertExpr(int i) {
return getRuleContext(OnSelectInsertExprContext.class,i);
}
public OutputClauseInsertContext outputClauseInsert() {
return getRuleContext(OutputClauseInsertContext.class,0);
}
public OnExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnExpr(this);
}
}
public final OnExprContext onExpr() throws RecognitionException {
OnExprContext _localctx = new OnExprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_onExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(702);
match(ON);
setState(703);
onStreamExpr();
setState(719);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DELETE:
{
setState(704);
onDeleteExpr();
}
break;
case SELECT:
case INSERT:
{
setState(705);
onSelectExpr();
setState(714);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(707);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(706);
onSelectInsertExpr();
}
}
setState(709);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==INSERT );
setState(712);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTPUT) {
{
setState(711);
outputClauseInsert();
}
}
}
}
}
break;
case SET:
{
setState(716);
onSetExpr();
}
break;
case UPDATE:
{
setState(717);
onUpdateExpr();
}
break;
case MERGE:
{
setState(718);
onMergeExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnStreamExprContext extends ParserRuleContext {
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public PatternInclusionExpressionContext patternInclusionExpression() {
return getRuleContext(PatternInclusionExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public OnStreamExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onStreamExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnStreamExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnStreamExpr(this);
}
}
public final OnStreamExprContext onStreamExpr() throws RecognitionException {
OnStreamExprContext _localctx = new OnStreamExprContext(_ctx, getState());
enterRule(_localctx, 34, RULE_onStreamExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(723);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(721);
eventFilterExpression();
}
break;
case PATTERN:
{
setState(722);
patternInclusionExpression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(728);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(725);
match(AS);
setState(726);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(727);
identOrTicked();
}
break;
case SELECT:
case INSERT:
case DELETE:
case SET:
case UPDATE:
case MERGE:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateExprContext extends ParserRuleContext {
public TerminalNode UPDATE() { return getToken(EsperEPL2GrammarParser.UPDATE, 0); }
public TerminalNode ISTREAM() { return getToken(EsperEPL2GrammarParser.ISTREAM, 0); }
public UpdateDetailsContext updateDetails() {
return getRuleContext(UpdateDetailsContext.class,0);
}
public UpdateExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUpdateExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUpdateExpr(this);
}
}
public final UpdateExprContext updateExpr() throws RecognitionException {
UpdateExprContext _localctx = new UpdateExprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_updateExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(730);
match(UPDATE);
setState(731);
match(ISTREAM);
setState(732);
updateDetails();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateDetailsContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public OnSetAssignmentListContext onSetAssignmentList() {
return getRuleContext(OnSetAssignmentListContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public UpdateDetailsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateDetails; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUpdateDetails(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUpdateDetails(this);
}
}
public final UpdateDetailsContext updateDetails() throws RecognitionException {
UpdateDetailsContext _localctx = new UpdateDetailsContext(_ctx, getState());
enterRule(_localctx, 38, RULE_updateDetails);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(734);
classIdentifier();
setState(738);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(735);
match(AS);
setState(736);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(737);
identOrTicked();
}
break;
case SET:
break;
default:
break;
}
setState(740);
match(SET);
setState(741);
onSetAssignmentList();
setState(744);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(742);
match(WHERE);
setState(743);
whereClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnMergeExprContext extends ParserRuleContext {
public Token n;
public TerminalNode MERGE() { return getToken(EsperEPL2GrammarParser.MERGE, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public OnMergeDirectInsertContext onMergeDirectInsert() {
return getRuleContext(OnMergeDirectInsertContext.class,0);
}
public TerminalNode INTO() { return getToken(EsperEPL2GrammarParser.INTO, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List mergeItem() {
return getRuleContexts(MergeItemContext.class);
}
public MergeItemContext mergeItem(int i) {
return getRuleContext(MergeItemContext.class,i);
}
public OnMergeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onMergeExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnMergeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnMergeExpr(this);
}
}
public final OnMergeExprContext onMergeExpr() throws RecognitionException {
OnMergeExprContext _localctx = new OnMergeExprContext(_ctx, getState());
enterRule(_localctx, 40, RULE_onMergeExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(746);
match(MERGE);
setState(748);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(747);
match(INTO);
}
}
setState(750);
((OnMergeExprContext)_localctx).n = match(IDENT);
setState(754);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(751);
match(AS);
setState(752);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(753);
identOrTicked();
}
break;
case WHERE:
case WHEN:
case INSERT:
break;
default:
break;
}
setState(766);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INSERT:
{
setState(756);
onMergeDirectInsert();
}
break;
case WHERE:
case WHEN:
{
setState(759);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(757);
match(WHERE);
setState(758);
whereClause();
}
}
setState(762);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(761);
mergeItem();
}
}
setState(764);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeItemContext extends ParserRuleContext {
public MergeMatchedContext mergeMatched() {
return getRuleContext(MergeMatchedContext.class,0);
}
public MergeUnmatchedContext mergeUnmatched() {
return getRuleContext(MergeUnmatchedContext.class,0);
}
public MergeItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeItem(this);
}
}
public final MergeItemContext mergeItem() throws RecognitionException {
MergeItemContext _localctx = new MergeItemContext(_ctx, getState());
enterRule(_localctx, 42, RULE_mergeItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(770);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(768);
mergeMatched();
}
break;
case 2:
{
setState(769);
mergeUnmatched();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeMatchedContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TerminalNode MATCHED() { return getToken(EsperEPL2GrammarParser.MATCHED, 0); }
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List mergeMatchedItem() {
return getRuleContexts(MergeMatchedItemContext.class);
}
public MergeMatchedItemContext mergeMatchedItem(int i) {
return getRuleContext(MergeMatchedItemContext.class,i);
}
public MergeMatchedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeMatched; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeMatched(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeMatched(this);
}
}
public final MergeMatchedContext mergeMatched() throws RecognitionException {
MergeMatchedContext _localctx = new MergeMatchedContext(_ctx, getState());
enterRule(_localctx, 44, RULE_mergeMatched);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(772);
match(WHEN);
setState(773);
match(MATCHED);
setState(776);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(774);
match(AND_EXPR);
setState(775);
expression();
}
}
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(778);
mergeMatchedItem();
}
}
setState(781);
_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, 46, RULE_mergeMatchedItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(783);
match(THEN);
setState(798);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UPDATE:
{
{
setState(784);
((MergeMatchedItemContext)_localctx).u = match(UPDATE);
setState(785);
match(SET);
setState(786);
onSetAssignmentList();
}
setState(790);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(788);
match(WHERE);
setState(789);
whereClause();
}
}
}
break;
case DELETE:
{
setState(792);
((MergeMatchedItemContext)_localctx).d = match(DELETE);
setState(795);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(793);
match(WHERE);
setState(794);
whereClause();
}
}
}
break;
case INSERT:
{
setState(797);
mergeInsert();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnMergeDirectInsertContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public OnMergeDirectInsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onMergeDirectInsert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnMergeDirectInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnMergeDirectInsert(this);
}
}
public final OnMergeDirectInsertContext onMergeDirectInsert() throws RecognitionException {
OnMergeDirectInsertContext _localctx = new OnMergeDirectInsertContext(_ctx, getState());
enterRule(_localctx, 48, RULE_onMergeDirectInsert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(800);
match(INSERT);
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(801);
match(LPAREN);
setState(802);
columnList();
setState(803);
match(RPAREN);
}
}
setState(807);
match(SELECT);
setState(808);
selectionList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MergeUnmatchedContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TerminalNode NOT_EXPR() { return getToken(EsperEPL2GrammarParser.NOT_EXPR, 0); }
public TerminalNode MATCHED() { return getToken(EsperEPL2GrammarParser.MATCHED, 0); }
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List mergeUnmatchedItem() {
return getRuleContexts(MergeUnmatchedItemContext.class);
}
public MergeUnmatchedItemContext mergeUnmatchedItem(int i) {
return getRuleContext(MergeUnmatchedItemContext.class,i);
}
public MergeUnmatchedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mergeUnmatched; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMergeUnmatched(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMergeUnmatched(this);
}
}
public final MergeUnmatchedContext mergeUnmatched() throws RecognitionException {
MergeUnmatchedContext _localctx = new MergeUnmatchedContext(_ctx, getState());
enterRule(_localctx, 50, RULE_mergeUnmatched);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(810);
match(WHEN);
setState(811);
match(NOT_EXPR);
setState(812);
match(MATCHED);
setState(815);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(813);
match(AND_EXPR);
setState(814);
expression();
}
}
setState(818);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(817);
mergeUnmatchedItem();
}
}
setState(820);
_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(822);
match(THEN);
setState(823);
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(825);
match(INSERT);
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(826);
match(INTO);
setState(827);
classIdentifier();
}
}
setState(834);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(830);
match(LPAREN);
setState(831);
columnList();
setState(832);
match(RPAREN);
}
}
setState(836);
match(SELECT);
setState(837);
selectionList();
setState(840);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(838);
match(WHERE);
setState(839);
whereClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSelectExprContext extends ParserRuleContext {
public Token d;
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public SelectionListContext selectionList() {
return getRuleContext(SelectionListContext.class,0);
}
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public InsertIntoExprContext insertIntoExpr() {
return getRuleContext(InsertIntoExprContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public OnExprFromContext onExprFrom() {
return getRuleContext(OnExprFromContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode GROUP() { return getToken(EsperEPL2GrammarParser.GROUP, 0); }
public List BY() { return getTokens(EsperEPL2GrammarParser.BY); }
public TerminalNode BY(int i) {
return getToken(EsperEPL2GrammarParser.BY, i);
}
public GroupByListExprContext groupByListExpr() {
return getRuleContext(GroupByListExprContext.class,0);
}
public TerminalNode HAVING() { return getToken(EsperEPL2GrammarParser.HAVING, 0); }
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public TerminalNode ORDER() { return getToken(EsperEPL2GrammarParser.ORDER, 0); }
public OrderByListExprContext orderByListExpr() {
return getRuleContext(OrderByListExprContext.class,0);
}
public TerminalNode ROW_LIMIT_EXPR() { return getToken(EsperEPL2GrammarParser.ROW_LIMIT_EXPR, 0); }
public RowLimitContext rowLimit() {
return getRuleContext(RowLimitContext.class,0);
}
public TerminalNode DELETE() { return getToken(EsperEPL2GrammarParser.DELETE, 0); }
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public OnSelectExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSelectExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSelectExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSelectExpr(this);
}
}
public final OnSelectExprContext onSelectExpr() throws RecognitionException {
OnSelectExprContext _localctx = new OnSelectExprContext(_ctx, getState());
enterRule(_localctx, 56, RULE_onSelectExpr);
paraphrases.push("on-select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(844);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(842);
match(INSERT);
setState(843);
insertIntoExpr();
}
}
setState(846);
match(SELECT);
setState(851);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR || _la==DELETE) {
{
setState(848);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(847);
match(AND_EXPR);
}
}
setState(850);
((OnSelectExprContext)_localctx).d = match(DELETE);
}
}
setState(854);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(853);
match(DISTINCT);
}
}
setState(856);
selectionList();
setState(858);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(857);
onExprFrom();
}
}
setState(862);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(860);
match(WHERE);
setState(861);
whereClause();
}
}
setState(867);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(864);
match(GROUP);
setState(865);
match(BY);
setState(866);
groupByListExpr();
}
}
setState(871);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(869);
match(HAVING);
setState(870);
havingClause();
}
}
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(873);
match(ORDER);
setState(874);
match(BY);
setState(875);
orderByListExpr();
}
}
setState(880);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW_LIMIT_EXPR) {
{
setState(878);
match(ROW_LIMIT_EXPR);
setState(879);
rowLimit();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnUpdateExprContext extends ParserRuleContext {
public Token n;
public TerminalNode UPDATE() { return getToken(EsperEPL2GrammarParser.UPDATE, 0); }
public TerminalNode SET() { return getToken(EsperEPL2GrammarParser.SET, 0); }
public OnSetAssignmentListContext onSetAssignmentList() {
return getRuleContext(OnSetAssignmentListContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public OnUpdateExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onUpdateExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnUpdateExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnUpdateExpr(this);
}
}
public final OnUpdateExprContext onUpdateExpr() throws RecognitionException {
OnUpdateExprContext _localctx = new OnUpdateExprContext(_ctx, getState());
enterRule(_localctx, 58, RULE_onUpdateExpr);
paraphrases.push("on-update clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(882);
match(UPDATE);
setState(883);
((OnUpdateExprContext)_localctx).n = match(IDENT);
setState(887);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(884);
match(AS);
setState(885);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(886);
identOrTicked();
}
break;
case SET:
break;
default:
break;
}
setState(889);
match(SET);
setState(890);
onSetAssignmentList();
setState(893);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(891);
match(WHERE);
setState(892);
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(895);
match(INSERT);
setState(896);
insertIntoExpr();
setState(897);
match(SELECT);
setState(898);
selectionList();
setState(900);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(899);
onSelectInsertFromClause();
}
}
setState(904);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(902);
match(WHERE);
setState(903);
whereClause();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSelectInsertFromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public PropertyExpressionContext propertyExpression() {
return getRuleContext(PropertyExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public OnSelectInsertFromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSelectInsertFromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSelectInsertFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSelectInsertFromClause(this);
}
}
public final OnSelectInsertFromClauseContext onSelectInsertFromClause() throws RecognitionException {
OnSelectInsertFromClauseContext _localctx = new OnSelectInsertFromClauseContext(_ctx, getState());
enterRule(_localctx, 62, RULE_onSelectInsertFromClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(906);
match(FROM);
setState(907);
propertyExpression();
setState(911);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(908);
match(AS);
setState(909);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(910);
identOrTicked();
}
break;
case EOF:
case WHERE:
case OUTPUT:
case INSERT:
case FOR:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputClauseInsertContext extends ParserRuleContext {
public Token f;
public Token a;
public TerminalNode OUTPUT() { return getToken(EsperEPL2GrammarParser.OUTPUT, 0); }
public TerminalNode FIRST() { return getToken(EsperEPL2GrammarParser.FIRST, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public OutputClauseInsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputClauseInsert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOutputClauseInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOutputClauseInsert(this);
}
}
public final OutputClauseInsertContext outputClauseInsert() throws RecognitionException {
OutputClauseInsertContext _localctx = new OutputClauseInsertContext(_ctx, getState());
enterRule(_localctx, 64, RULE_outputClauseInsert);
try {
enterOuterAlt(_localctx, 1);
{
setState(913);
match(OUTPUT);
setState(916);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FIRST:
{
setState(914);
((OutputClauseInsertContext)_localctx).f = match(FIRST);
}
break;
case ALL:
{
setState(915);
((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(918);
match(DELETE);
setState(919);
onExprFrom();
setState(922);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(920);
match(WHERE);
setState(921);
whereClause();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class 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(924);
match(SET);
setState(925);
onSetAssignmentList();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnSetAssignmentListContext extends ParserRuleContext {
public List onSetAssignment() {
return getRuleContexts(OnSetAssignmentContext.class);
}
public OnSetAssignmentContext onSetAssignment(int i) {
return getRuleContext(OnSetAssignmentContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public OnSetAssignmentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onSetAssignmentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnSetAssignmentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnSetAssignmentList(this);
}
}
public final OnSetAssignmentListContext onSetAssignmentList() throws RecognitionException {
OnSetAssignmentListContext _localctx = new OnSetAssignmentListContext(_ctx, getState());
enterRule(_localctx, 70, RULE_onSetAssignmentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(927);
onSetAssignment();
setState(932);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(928);
match(COMMA);
setState(929);
onSetAssignment();
}
}
setState(934);
_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(940);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(935);
eventProperty();
setState(936);
match(EQUALS);
setState(937);
expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(939);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnExprFromContext extends ParserRuleContext {
public Token n;
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public OnExprFromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onExprFrom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOnExprFrom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOnExprFrom(this);
}
}
public final OnExprFromContext onExprFrom() throws RecognitionException {
OnExprFromContext _localctx = new OnExprFromContext(_ctx, getState());
enterRule(_localctx, 74, RULE_onExprFrom);
try {
enterOuterAlt(_localctx, 1);
{
setState(942);
match(FROM);
setState(943);
((OnExprFromContext)_localctx).n = match(IDENT);
setState(947);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(944);
match(AS);
setState(945);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(946);
identOrTicked();
}
break;
case EOF:
case WHERE:
case GROUP:
case HAVING:
case INSERT:
case ORDER:
case ROW_LIMIT_EXPR:
case FOR:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateWindowExprContext extends ParserRuleContext {
public Token i;
public Token ru;
public Token ri;
public Token i1;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode WINDOW() { return getToken(EsperEPL2GrammarParser.WINDOW, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CreateWindowExprModelAfterContext createWindowExprModelAfter() {
return getRuleContext(CreateWindowExprModelAfterContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public CreateColumnListContext createColumnList() {
return getRuleContext(CreateColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ViewExpressionsContext viewExpressions() {
return getRuleContext(ViewExpressionsContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public TerminalNode INSERT() { return getToken(EsperEPL2GrammarParser.INSERT, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public CreateWindowExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createWindowExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateWindowExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateWindowExpr(this);
}
}
public final CreateWindowExprContext createWindowExpr() throws RecognitionException {
CreateWindowExprContext _localctx = new CreateWindowExprContext(_ctx, getState());
enterRule(_localctx, 76, RULE_createWindowExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(949);
match(CREATE);
setState(950);
match(WINDOW);
setState(951);
((CreateWindowExprContext)_localctx).i = match(IDENT);
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(952);
viewExpressions();
}
}
setState(957);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(955);
((CreateWindowExprContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(956);
((CreateWindowExprContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case AS:
case SELECT:
case EVENTS:
case LPAREN:
case TICKED_STRING_LITERAL:
case IDENT:
break;
default:
break;
}
setState(960);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(959);
match(AS);
}
}
setState(967);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(962);
createWindowExprModelAfter();
}
break;
case LPAREN:
{
setState(963);
match(LPAREN);
setState(964);
createColumnList();
setState(965);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(974);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(969);
((CreateWindowExprContext)_localctx).i1 = match(INSERT);
setState(972);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(970);
match(WHERE);
setState(971);
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(980);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(976);
match(SELECT);
setState(977);
createSelectionList();
setState(978);
match(FROM);
}
}
setState(982);
classIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateIndexExprContext extends ParserRuleContext {
public Token u;
public Token n;
public Token w;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode INDEX() { return getToken(EsperEPL2GrammarParser.INDEX, 0); }
public TerminalNode ON() { return getToken(EsperEPL2GrammarParser.ON, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public CreateIndexColumnListContext createIndexColumnList() {
return getRuleContext(CreateIndexColumnListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public CreateIndexExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndexExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateIndexExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateIndexExpr(this);
}
}
public final CreateIndexExprContext createIndexExpr() throws RecognitionException {
CreateIndexExprContext _localctx = new CreateIndexExprContext(_ctx, getState());
enterRule(_localctx, 80, RULE_createIndexExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(984);
match(CREATE);
setState(986);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(985);
((CreateIndexExprContext)_localctx).u = match(IDENT);
}
}
setState(988);
match(INDEX);
setState(989);
((CreateIndexExprContext)_localctx).n = match(IDENT);
setState(990);
match(ON);
setState(991);
((CreateIndexExprContext)_localctx).w = match(IDENT);
setState(992);
match(LPAREN);
setState(993);
createIndexColumnList();
setState(994);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateIndexColumnListContext extends ParserRuleContext {
public List createIndexColumn() {
return getRuleContexts(CreateIndexColumnContext.class);
}
public CreateIndexColumnContext createIndexColumn(int i) {
return getRuleContext(CreateIndexColumnContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateIndexColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndexColumnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateIndexColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateIndexColumnList(this);
}
}
public final CreateIndexColumnListContext createIndexColumnList() throws RecognitionException {
CreateIndexColumnListContext _localctx = new CreateIndexColumnListContext(_ctx, getState());
enterRule(_localctx, 82, RULE_createIndexColumnList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(996);
createIndexColumn();
setState(1001);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(997);
match(COMMA);
setState(998);
createIndexColumn();
}
}
setState(1003);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateIndexColumnContext extends ParserRuleContext {
public ExpressionListContext i;
public Token t;
public ExpressionListContext p;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public List RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public CreateIndexColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createIndexColumn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateIndexColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateIndexColumn(this);
}
}
public final CreateIndexColumnContext createIndexColumn() throws RecognitionException {
CreateIndexColumnContext _localctx = new CreateIndexColumnContext(_ctx, getState());
enterRule(_localctx, 84, RULE_createIndexColumn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1010);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(1004);
expression();
}
break;
case 2:
{
setState(1005);
match(LPAREN);
setState(1007);
_errHandler.sync(this);
_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(1006);
((CreateIndexColumnContext)_localctx).i = expressionList();
}
}
setState(1009);
match(RPAREN);
}
break;
}
setState(1020);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1012);
((CreateIndexColumnContext)_localctx).t = match(IDENT);
setState(1018);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1013);
match(LPAREN);
setState(1015);
_errHandler.sync(this);
_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(1014);
((CreateIndexColumnContext)_localctx).p = expressionList();
}
}
setState(1017);
match(RPAREN);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateVariableExprContext extends ParserRuleContext {
public Token c;
public Token n;
public TerminalNode CREATE() { return getToken(EsperEPL2GrammarParser.CREATE, 0); }
public TerminalNode VARIABLE() { return getToken(EsperEPL2GrammarParser.VARIABLE, 0); }
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode EQUALS() { return getToken(EsperEPL2GrammarParser.EQUALS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public CreateVariableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createVariableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateVariableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateVariableExpr(this);
}
}
public final CreateVariableExprContext createVariableExpr() throws RecognitionException {
CreateVariableExprContext _localctx = new CreateVariableExprContext(_ctx, getState());
enterRule(_localctx, 86, RULE_createVariableExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1022);
match(CREATE);
setState(1024);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1023);
((CreateVariableExprContext)_localctx).c = match(IDENT);
}
}
setState(1026);
match(VARIABLE);
setState(1027);
classIdentifierWithDimensions();
setState(1028);
((CreateVariableExprContext)_localctx).n = match(IDENT);
setState(1031);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(1029);
match(EQUALS);
setState(1030);
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(1033);
match(CREATE);
setState(1034);
match(TABLE);
setState(1035);
((CreateTableExprContext)_localctx).n = match(IDENT);
setState(1037);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1036);
match(AS);
}
}
setState(1039);
match(LPAREN);
setState(1040);
createTableColumnList();
setState(1041);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableColumnListContext extends ParserRuleContext {
public List createTableColumn() {
return getRuleContexts(CreateTableColumnContext.class);
}
public CreateTableColumnContext createTableColumn(int i) {
return getRuleContext(CreateTableColumnContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateTableColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableColumnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateTableColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateTableColumnList(this);
}
}
public final CreateTableColumnListContext createTableColumnList() throws RecognitionException {
CreateTableColumnListContext _localctx = new CreateTableColumnListContext(_ctx, getState());
enterRule(_localctx, 90, RULE_createTableColumnList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1043);
createTableColumn();
setState(1048);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1044);
match(COMMA);
setState(1045);
createTableColumn();
}
}
setState(1050);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableColumnContext extends ParserRuleContext {
public Token n;
public Token p;
public Token k;
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public BuiltinFuncContext builtinFunc() {
return getRuleContext(BuiltinFuncContext.class,0);
}
public LibFunctionContext libFunction() {
return getRuleContext(LibFunctionContext.class,0);
}
public List typeExpressionAnnotation() {
return getRuleContexts(TypeExpressionAnnotationContext.class);
}
public TypeExpressionAnnotationContext typeExpressionAnnotation(int i) {
return getRuleContext(TypeExpressionAnnotationContext.class,i);
}
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public CreateTableColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableColumn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateTableColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateTableColumn(this);
}
}
public final CreateTableColumnContext createTableColumn() throws RecognitionException {
CreateTableColumnContext _localctx = new CreateTableColumnContext(_ctx, getState());
enterRule(_localctx, 92, RULE_createTableColumn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1051);
((CreateTableColumnContext)_localctx).n = match(IDENT);
setState(1055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(1052);
classIdentifierWithDimensions();
}
break;
case 2:
{
setState(1053);
builtinFunc();
}
break;
case 3:
{
setState(1054);
libFunction();
}
break;
}
setState(1058);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(1057);
((CreateTableColumnContext)_localctx).p = match(IDENT);
}
break;
}
setState(1061);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1060);
((CreateTableColumnContext)_localctx).k = match(IDENT);
}
}
setState(1067);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
setState(1065);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1063);
typeExpressionAnnotation();
}
break;
case 2:
{
setState(1064);
annotationEnum();
}
break;
}
}
setState(1069);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateColumnListContext extends ParserRuleContext {
public List createColumnListElement() {
return getRuleContexts(CreateColumnListElementContext.class);
}
public CreateColumnListElementContext createColumnListElement(int i) {
return getRuleContext(CreateColumnListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createColumnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateColumnList(this);
}
}
public final CreateColumnListContext createColumnList() throws RecognitionException {
CreateColumnListContext _localctx = new CreateColumnListContext(_ctx, getState());
enterRule(_localctx, 94, 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 ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode VALUE_NULL() { return getToken(EsperEPL2GrammarParser.VALUE_NULL, 0); }
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public CreateColumnListElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createColumnListElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateColumnListElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateColumnListElement(this);
}
}
public final CreateColumnListElementContext createColumnListElement() throws RecognitionException {
CreateColumnListElementContext _localctx = new CreateColumnListElementContext(_ctx, getState());
enterRule(_localctx, 96, RULE_createColumnListElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1078);
classIdentifier();
setState(1081);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VALUE_NULL:
{
setState(1079);
match(VALUE_NULL);
}
break;
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1080);
classIdentifierWithDimensions();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSelectionListContext extends ParserRuleContext {
public List createSelectionListElement() {
return getRuleContexts(CreateSelectionListElementContext.class);
}
public CreateSelectionListElementContext createSelectionListElement(int i) {
return getRuleContext(CreateSelectionListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateSelectionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSelectionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSelectionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSelectionList(this);
}
}
public final CreateSelectionListContext createSelectionList() throws RecognitionException {
CreateSelectionListContext _localctx = new CreateSelectionListContext(_ctx, getState());
enterRule(_localctx, 98, RULE_createSelectionList);
paraphrases.push("select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1083);
createSelectionListElement();
setState(1088);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1084);
match(COMMA);
setState(1085);
createSelectionListElement();
}
}
setState(1090);
_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, 100, RULE_createSelectionListElement);
int _la;
try {
setState(1101);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1091);
((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(1092);
eventProperty();
setState(1095);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1093);
match(AS);
setState(1094);
((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(1097);
constant();
setState(1098);
match(AS);
setState(1099);
((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, 102, RULE_createSchemaExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1103);
match(CREATE);
setState(1105);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1104);
((CreateSchemaExprContext)_localctx).keyword = match(IDENT);
}
}
setState(1107);
createSchemaDef();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSchemaDefContext extends ParserRuleContext {
public Token name;
public TerminalNode SCHEMA() { return getToken(EsperEPL2GrammarParser.SCHEMA, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public VariantListContext variantList() {
return getRuleContext(VariantListContext.class,0);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public List createSchemaQual() {
return getRuleContexts(CreateSchemaQualContext.class);
}
public CreateSchemaQualContext createSchemaQual(int i) {
return getRuleContext(CreateSchemaQualContext.class,i);
}
public CreateColumnListContext createColumnList() {
return getRuleContext(CreateColumnListContext.class,0);
}
public CreateSchemaDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSchemaDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSchemaDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSchemaDef(this);
}
}
public final CreateSchemaDefContext createSchemaDef() throws RecognitionException {
CreateSchemaDefContext _localctx = new CreateSchemaDefContext(_ctx, getState());
enterRule(_localctx, 104, RULE_createSchemaDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1109);
match(SCHEMA);
setState(1110);
((CreateSchemaDefContext)_localctx).name = match(IDENT);
setState(1112);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1111);
match(AS);
}
}
setState(1120);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case STAR:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1114);
variantList();
}
break;
case LPAREN:
{
setState(1115);
match(LPAREN);
setState(1117);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EVENTS || _la==TICKED_STRING_LITERAL || _la==IDENT) {
{
setState(1116);
createColumnList();
}
}
setState(1119);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1125);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENT) {
{
{
setState(1122);
createSchemaQual();
}
}
setState(1127);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FafDeleteContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(EsperEPL2GrammarParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public FafDeleteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fafDelete; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFafDelete(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFafDelete(this);
}
}
public final FafDeleteContext fafDelete() throws RecognitionException {
FafDeleteContext _localctx = new FafDeleteContext(_ctx, getState());
enterRule(_localctx, 106, RULE_fafDelete);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1128);
match(DELETE);
setState(1129);
match(FROM);
setState(1130);
classIdentifier();
setState(1134);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(1131);
match(AS);
setState(1132);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1133);
identOrTicked();
}
break;
case EOF:
case WHERE:
case FOR:
break;
default:
break;
}
setState(1138);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1136);
match(WHERE);
setState(1137);
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, 108, RULE_fafUpdate);
try {
enterOuterAlt(_localctx, 1);
{
setState(1140);
match(UPDATE);
setState(1141);
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, 110, RULE_fafInsert);
try {
enterOuterAlt(_localctx, 1);
{
setState(1143);
match(INSERT);
setState(1144);
insertIntoExpr();
setState(1145);
match(VALUES);
setState(1146);
match(LPAREN);
setState(1147);
expressionList();
setState(1148);
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, 112, RULE_createDataflow);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1150);
match(CREATE);
setState(1151);
match(DATAFLOW);
setState(1152);
((CreateDataflowContext)_localctx).name = match(IDENT);
setState(1154);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1153);
match(AS);
}
}
setState(1156);
gopList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopListContext extends ParserRuleContext {
public List gop() {
return getRuleContexts(GopContext.class);
}
public GopContext gop(int i) {
return getRuleContext(GopContext.class,i);
}
public GopListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopList(this);
}
}
public final GopListContext gopList() throws RecognitionException {
GopListContext _localctx = new GopListContext(_ctx, getState());
enterRule(_localctx, 114, RULE_gopList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1158);
gop();
setState(1162);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CREATE || _la==SELECT || _la==ATCHAR || _la==IDENT) {
{
{
setState(1159);
gop();
}
}
setState(1164);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopContext extends ParserRuleContext {
public Token opName;
public Token s;
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode SELECT() { return getToken(EsperEPL2GrammarParser.SELECT, 0); }
public GopParamsContext gopParams() {
return getRuleContext(GopParamsContext.class,0);
}
public GopOutContext gopOut() {
return getRuleContext(GopOutContext.class,0);
}
public GopDetailContext gopDetail() {
return getRuleContext(GopDetailContext.class,0);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public CreateSchemaExprContext createSchemaExpr() {
return getRuleContext(CreateSchemaExprContext.class,0);
}
public GopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGop(this);
}
}
public final GopContext gop() throws RecognitionException {
GopContext _localctx = new GopContext(_ctx, getState());
enterRule(_localctx, 116, RULE_gop);
int _la;
try {
setState(1192);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
case ATCHAR:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(1168);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
{
setState(1165);
annotationEnum();
}
}
setState(1170);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1173);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(1171);
((GopContext)_localctx).opName = match(IDENT);
}
break;
case SELECT:
{
setState(1172);
((GopContext)_localctx).s = match(SELECT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1176);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1175);
gopParams();
}
}
setState(1179);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOLLOWED_BY) {
{
setState(1178);
gopOut();
}
}
setState(1181);
match(LCURLY);
setState(1183);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT || _la==IDENT) {
{
setState(1182);
gopDetail();
}
}
setState(1186);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1185);
match(COMMA);
}
}
setState(1188);
match(RCURLY);
}
break;
case CREATE:
enterOuterAlt(_localctx, 2);
{
setState(1189);
createSchemaExpr();
setState(1190);
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, 118, RULE_gopParams);
try {
enterOuterAlt(_localctx, 1);
{
setState(1194);
match(LPAREN);
setState(1195);
gopParamsItemList();
setState(1196);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsItemListContext extends ParserRuleContext {
public List gopParamsItem() {
return getRuleContexts(GopParamsItemContext.class);
}
public GopParamsItemContext gopParamsItem(int i) {
return getRuleContext(GopParamsItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopParamsItemListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParamsItemList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParamsItemList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParamsItemList(this);
}
}
public final GopParamsItemListContext gopParamsItemList() throws RecognitionException {
GopParamsItemListContext _localctx = new GopParamsItemListContext(_ctx, getState());
enterRule(_localctx, 120, RULE_gopParamsItemList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1198);
gopParamsItem();
setState(1203);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1199);
match(COMMA);
setState(1200);
gopParamsItem();
}
}
setState(1205);
_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, 122, RULE_gopParamsItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1208);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1206);
((GopParamsItemContext)_localctx).n = classIdentifier();
}
break;
case LPAREN:
{
setState(1207);
gopParamsItemMany();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1211);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1210);
gopParamsItemAs();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopParamsItemManyContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List classIdentifier() {
return getRuleContexts(ClassIdentifierContext.class);
}
public ClassIdentifierContext classIdentifier(int i) {
return getRuleContext(ClassIdentifierContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public GopParamsItemManyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopParamsItemMany; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopParamsItemMany(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopParamsItemMany(this);
}
}
public final GopParamsItemManyContext gopParamsItemMany() throws RecognitionException {
GopParamsItemManyContext _localctx = new GopParamsItemManyContext(_ctx, getState());
enterRule(_localctx, 124, RULE_gopParamsItemMany);
try {
enterOuterAlt(_localctx, 1);
{
setState(1213);
match(LPAREN);
setState(1214);
classIdentifier();
{
setState(1215);
match(COMMA);
setState(1216);
classIdentifier();
}
setState(1218);
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, 126, RULE_gopParamsItemAs);
try {
enterOuterAlt(_localctx, 1);
{
setState(1220);
match(AS);
setState(1221);
((GopParamsItemAsContext)_localctx).a = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutContext extends ParserRuleContext {
public TerminalNode FOLLOWED_BY() { return getToken(EsperEPL2GrammarParser.FOLLOWED_BY, 0); }
public List gopOutItem() {
return getRuleContexts(GopOutItemContext.class);
}
public GopOutItemContext gopOutItem(int i) {
return getRuleContext(GopOutItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopOutContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOut; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOut(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOut(this);
}
}
public final GopOutContext gopOut() throws RecognitionException {
GopOutContext _localctx = new GopOutContext(_ctx, getState());
enterRule(_localctx, 128, RULE_gopOut);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1223);
match(FOLLOWED_BY);
setState(1224);
gopOutItem();
setState(1229);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1225);
match(COMMA);
setState(1226);
gopOutItem();
}
}
setState(1231);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class 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, 130, RULE_gopOutItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1232);
((GopOutItemContext)_localctx).n = classIdentifier();
setState(1234);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1233);
gopOutTypeList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopOutTypeListContext extends ParserRuleContext {
public TerminalNode LT() { return getToken(EsperEPL2GrammarParser.LT, 0); }
public List gopOutTypeParam() {
return getRuleContexts(GopOutTypeParamContext.class);
}
public GopOutTypeParamContext gopOutTypeParam(int i) {
return getRuleContext(GopOutTypeParamContext.class,i);
}
public TerminalNode GT() { return getToken(EsperEPL2GrammarParser.GT, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopOutTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopOutTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopOutTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopOutTypeList(this);
}
}
public final GopOutTypeListContext gopOutTypeList() throws RecognitionException {
GopOutTypeListContext _localctx = new GopOutTypeListContext(_ctx, getState());
enterRule(_localctx, 132, RULE_gopOutTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1236);
match(LT);
setState(1237);
gopOutTypeParam();
setState(1242);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1238);
match(COMMA);
setState(1239);
gopOutTypeParam();
}
}
setState(1244);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1245);
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, 134, RULE_gopOutTypeParam);
try {
enterOuterAlt(_localctx, 1);
{
setState(1249);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1247);
gopOutTypeItem();
}
break;
case QUESTION:
{
setState(1248);
((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, 136, RULE_gopOutTypeItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1251);
classIdentifier();
setState(1253);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1252);
gopOutTypeList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GopDetailContext extends ParserRuleContext {
public List gopConfig() {
return getRuleContexts(GopConfigContext.class);
}
public GopConfigContext gopConfig(int i) {
return getRuleContext(GopConfigContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GopDetailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gopDetail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGopDetail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGopDetail(this);
}
}
public final GopDetailContext gopDetail() throws RecognitionException {
GopDetailContext _localctx = new GopDetailContext(_ctx, getState());
enterRule(_localctx, 138, RULE_gopDetail);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1255);
gopConfig();
setState(1260);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,129,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1256);
match(COMMA);
setState(1257);
gopConfig();
}
}
}
setState(1262);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,129,_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, 140, RULE_gopConfig);
int _la;
try {
setState(1276);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(1263);
match(SELECT);
setState(1264);
_la = _input.LA(1);
if ( !(_la==EQUALS || _la==COLON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1265);
match(LPAREN);
setState(1266);
selectExpr();
setState(1267);
match(RPAREN);
}
break;
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1269);
((GopConfigContext)_localctx).n = match(IDENT);
setState(1270);
_la = _input.LA(1);
if ( !(_la==EQUALS || _la==COLON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1274);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(1271);
expression();
}
break;
case 2:
{
setState(1272);
jsonobject();
}
break;
case 3:
{
setState(1273);
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, 142, RULE_createContextExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1278);
match(CREATE);
setState(1279);
match(CONTEXT);
setState(1280);
((CreateContextExprContext)_localctx).name = match(IDENT);
setState(1282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1281);
match(AS);
}
}
setState(1284);
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, 144, RULE_createExpressionExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1286);
match(CREATE);
setState(1287);
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 contextContextNested() {
return getRuleContexts(ContextContextNestedContext.class);
}
public ContextContextNestedContext contextContextNested(int i) {
return getRuleContext(ContextContextNestedContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateContextDetailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextDetail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextDetail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextDetail(this);
}
}
public final CreateContextDetailContext createContextDetail() throws RecognitionException {
CreateContextDetailContext _localctx = new CreateContextDetailContext(_ctx, getState());
enterRule(_localctx, 146, RULE_createContextDetail);
int _la;
try {
setState(1300);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COALESCE:
case GROUP:
case PARTITION:
case START:
case INITIATED:
enterOuterAlt(_localctx, 1);
{
setState(1289);
createContextChoice();
}
break;
case CONTEXT:
enterOuterAlt(_localctx, 2);
{
setState(1290);
contextContextNested();
setState(1291);
match(COMMA);
setState(1292);
contextContextNested();
setState(1297);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1293);
match(COMMA);
setState(1294);
contextContextNested();
}
}
setState(1299);
_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, 148, RULE_contextContextNested);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1302);
match(CONTEXT);
setState(1303);
((ContextContextNestedContext)_localctx).name = match(IDENT);
setState(1305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1304);
match(AS);
}
}
setState(1307);
createContextChoice();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextChoiceContext extends ParserRuleContext {
public Token i;
public CreateContextRangePointContext r1;
public CreateContextRangePointContext r2;
public Token g;
public Token p;
public TerminalNode START() { return getToken(EsperEPL2GrammarParser.START, 0); }
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List createContextRangePoint() {
return getRuleContexts(CreateContextRangePointContext.class);
}
public CreateContextRangePointContext createContextRangePoint(int i) {
return getRuleContext(CreateContextRangePointContext.class,i);
}
public TerminalNode END() { return getToken(EsperEPL2GrammarParser.END, 0); }
public TerminalNode INITIATED() { return getToken(EsperEPL2GrammarParser.INITIATED, 0); }
public List BY() { return getTokens(EsperEPL2GrammarParser.BY); }
public TerminalNode BY(int i) {
return getToken(EsperEPL2GrammarParser.BY, i);
}
public CreateContextDistinctContext createContextDistinct() {
return getRuleContext(CreateContextDistinctContext.class,0);
}
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public TerminalNode PARTITION() { return getToken(EsperEPL2GrammarParser.PARTITION, 0); }
public List createContextPartitionItem() {
return getRuleContexts(CreateContextPartitionItemContext.class);
}
public CreateContextPartitionItemContext createContextPartitionItem(int i) {
return getRuleContext(CreateContextPartitionItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateContextPartitionInitContext createContextPartitionInit() {
return getRuleContext(CreateContextPartitionInitContext.class,0);
}
public CreateContextPartitionTermContext createContextPartitionTerm() {
return getRuleContext(CreateContextPartitionTermContext.class,0);
}
public List createContextGroupItem() {
return getRuleContexts(CreateContextGroupItemContext.class);
}
public CreateContextGroupItemContext createContextGroupItem(int i) {
return getRuleContext(CreateContextGroupItemContext.class,i);
}
public TerminalNode FROM() { return getToken(EsperEPL2GrammarParser.FROM, 0); }
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public TerminalNode COALESCE() { return getToken(EsperEPL2GrammarParser.COALESCE, 0); }
public List createContextCoalesceItem() {
return getRuleContexts(CreateContextCoalesceItemContext.class);
}
public CreateContextCoalesceItemContext createContextCoalesceItem(int i) {
return getRuleContext(CreateContextCoalesceItemContext.class,i);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public CreateContextChoiceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextChoice; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextChoice(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextChoice(this);
}
}
public final CreateContextChoiceContext createContextChoice() throws RecognitionException {
CreateContextChoiceContext _localctx = new CreateContextChoiceContext(_ctx, getState());
enterRule(_localctx, 150, RULE_createContextChoice);
int _la;
try {
int _alt;
setState(1385);
_errHandler.sync(this);
switch (_input.LA(1)) {
case START:
enterOuterAlt(_localctx, 1);
{
setState(1309);
match(START);
setState(1313);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATCHAR:
{
setState(1310);
match(ATCHAR);
setState(1311);
((CreateContextChoiceContext)_localctx).i = match(IDENT);
}
break;
case EVENTS:
case PATTERN:
case AFTER:
case LPAREN:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1312);
((CreateContextChoiceContext)_localctx).r1 = createContextRangePoint();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1317);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==END) {
{
setState(1315);
match(END);
setState(1316);
((CreateContextChoiceContext)_localctx).r2 = createContextRangePoint();
}
}
}
break;
case INITIATED:
enterOuterAlt(_localctx, 2);
{
setState(1319);
match(INITIATED);
setState(1321);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1320);
match(BY);
}
}
setState(1324);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1323);
createContextDistinct();
}
}
setState(1329);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1326);
match(ATCHAR);
setState(1327);
((CreateContextChoiceContext)_localctx).i = match(IDENT);
setState(1328);
match(AND_EXPR);
}
}
setState(1331);
((CreateContextChoiceContext)_localctx).r1 = createContextRangePoint();
setState(1337);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TERMINATED) {
{
setState(1332);
match(TERMINATED);
setState(1334);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1333);
match(BY);
}
}
setState(1336);
((CreateContextChoiceContext)_localctx).r2 = createContextRangePoint();
}
}
}
break;
case PARTITION:
enterOuterAlt(_localctx, 3);
{
setState(1339);
match(PARTITION);
setState(1341);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1340);
match(BY);
}
}
setState(1343);
createContextPartitionItem();
setState(1348);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1344);
match(COMMA);
setState(1345);
createContextPartitionItem();
}
}
}
setState(1350);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
}
setState(1352);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIATED) {
{
setState(1351);
createContextPartitionInit();
}
}
setState(1355);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TERMINATED) {
{
setState(1354);
createContextPartitionTerm();
}
}
}
break;
case GROUP:
enterOuterAlt(_localctx, 4);
{
setState(1357);
createContextGroupItem();
setState(1362);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1358);
match(COMMA);
setState(1359);
createContextGroupItem();
}
}
setState(1364);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1365);
match(FROM);
setState(1366);
eventFilterExpression();
}
break;
case COALESCE:
enterOuterAlt(_localctx, 5);
{
setState(1368);
match(COALESCE);
setState(1370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1369);
match(BY);
}
}
setState(1372);
createContextCoalesceItem();
setState(1377);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1373);
match(COMMA);
setState(1374);
createContextCoalesceItem();
}
}
setState(1379);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1380);
((CreateContextChoiceContext)_localctx).g = match(IDENT);
setState(1381);
number();
setState(1383);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1382);
((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, 152, RULE_createContextDistinct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1387);
match(DISTINCT);
setState(1388);
match(LPAREN);
setState(1390);
_errHandler.sync(this);
_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(1389);
expressionList();
}
}
setState(1392);
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 CrontabLimitParameterSetListContext crontabLimitParameterSetList() {
return getRuleContext(CrontabLimitParameterSetListContext.class,0);
}
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public TimePeriodContext timePeriod() {
return getRuleContext(TimePeriodContext.class,0);
}
public CreateContextRangePointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextRangePoint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextRangePoint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextRangePoint(this);
}
}
public final CreateContextRangePointContext createContextRangePoint() throws RecognitionException {
CreateContextRangePointContext _localctx = new CreateContextRangePointContext(_ctx, getState());
enterRule(_localctx, 154, RULE_createContextRangePoint);
int _la;
try {
setState(1403);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(1394);
createContextFilter();
}
break;
case PATTERN:
enterOuterAlt(_localctx, 2);
{
setState(1395);
patternInclusionExpression();
setState(1398);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1396);
match(ATCHAR);
setState(1397);
((CreateContextRangePointContext)_localctx).i = match(IDENT);
}
}
}
break;
case LPAREN:
enterOuterAlt(_localctx, 3);
{
setState(1400);
crontabLimitParameterSetList();
}
break;
case AFTER:
enterOuterAlt(_localctx, 4);
{
setState(1401);
match(AFTER);
setState(1402);
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, 156, RULE_createContextFilter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1405);
eventFilterExpression();
setState(1410);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENT) {
{
setState(1407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1406);
match(AS);
}
}
setState(1409);
((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 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 KeywordAllowedIdentContext keywordAllowedIdent() {
return getRuleContext(KeywordAllowedIdentContext.class,0);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public CreateContextPartitionItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextPartitionItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextPartitionItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextPartitionItem(this);
}
}
public final CreateContextPartitionItemContext createContextPartitionItem() throws RecognitionException {
CreateContextPartitionItemContext _localctx = new CreateContextPartitionItemContext(_ctx, getState());
enterRule(_localctx, 158, RULE_createContextPartitionItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1412);
eventProperty();
setState(1417);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR || _la==COMMA) {
{
{
setState(1413);
_la = _input.LA(1);
if ( !(_la==AND_EXPR || _la==COMMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1414);
eventProperty();
}
}
setState(1419);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1420);
match(FROM);
setState(1421);
eventFilterExpression();
setState(1426);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1423);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1422);
match(AS);
}
}
setState(1425);
keywordAllowedIdent();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextCoalesceItemContext extends ParserRuleContext {
public 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, 160, RULE_createContextCoalesceItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1428);
libFunctionNoClass();
setState(1429);
match(FROM);
setState(1430);
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, 162, RULE_createContextGroupItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1432);
match(GROUP);
setState(1434);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1433);
match(BY);
}
}
setState(1436);
expression();
setState(1437);
match(AS);
setState(1438);
((CreateContextGroupItemContext)_localctx).i = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextPartitionInitContext extends ParserRuleContext {
public TerminalNode INITIATED() { return getToken(EsperEPL2GrammarParser.INITIATED, 0); }
public List createContextFilter() {
return getRuleContexts(CreateContextFilterContext.class);
}
public CreateContextFilterContext createContextFilter(int i) {
return getRuleContext(CreateContextFilterContext.class,i);
}
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CreateContextPartitionInitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextPartitionInit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextPartitionInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextPartitionInit(this);
}
}
public final CreateContextPartitionInitContext createContextPartitionInit() throws RecognitionException {
CreateContextPartitionInitContext _localctx = new CreateContextPartitionInitContext(_ctx, getState());
enterRule(_localctx, 164, RULE_createContextPartitionInit);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1440);
match(INITIATED);
setState(1442);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1441);
match(BY);
}
}
setState(1444);
createContextFilter();
setState(1449);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1445);
match(COMMA);
setState(1446);
createContextFilter();
}
}
}
setState(1451);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContextPartitionTermContext extends ParserRuleContext {
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public CreateContextRangePointContext createContextRangePoint() {
return getRuleContext(CreateContextRangePointContext.class,0);
}
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public CreateContextPartitionTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createContextPartitionTerm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateContextPartitionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateContextPartitionTerm(this);
}
}
public final CreateContextPartitionTermContext createContextPartitionTerm() throws RecognitionException {
CreateContextPartitionTermContext _localctx = new CreateContextPartitionTermContext(_ctx, getState());
enterRule(_localctx, 166, RULE_createContextPartitionTerm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1452);
match(TERMINATED);
setState(1454);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1453);
match(BY);
}
}
setState(1456);
createContextRangePoint();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSchemaQualContext extends ParserRuleContext {
public Token i;
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public CreateSchemaQualContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSchemaQual; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCreateSchemaQual(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCreateSchemaQual(this);
}
}
public final CreateSchemaQualContext createSchemaQual() throws RecognitionException {
CreateSchemaQualContext _localctx = new CreateSchemaQualContext(_ctx, getState());
enterRule(_localctx, 168, RULE_createSchemaQual);
try {
enterOuterAlt(_localctx, 1);
{
setState(1458);
((CreateSchemaQualContext)_localctx).i = match(IDENT);
setState(1459);
columnList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariantListContext extends ParserRuleContext {
public List variantListElement() {
return getRuleContexts(VariantListElementContext.class);
}
public VariantListElementContext variantListElement(int i) {
return getRuleContext(VariantListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public VariantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterVariantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitVariantList(this);
}
}
public final VariantListContext variantList() throws RecognitionException {
VariantListContext _localctx = new VariantListContext(_ctx, getState());
enterRule(_localctx, 170, RULE_variantList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1461);
variantListElement();
setState(1466);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,164,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1462);
match(COMMA);
setState(1463);
variantListElement();
}
}
}
setState(1468);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,164,_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, 172, RULE_variantListElement);
try {
setState(1471);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1469);
match(STAR);
}
break;
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 2);
{
setState(1470);
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, 174, RULE_intoTableExpr);
paraphrases.push("into-table clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1473);
match(TABLE);
setState(1474);
((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, 176, RULE_insertIntoExpr);
paraphrases.push("insert-into clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1479);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ISTREAM:
{
setState(1476);
((InsertIntoExprContext)_localctx).i = match(ISTREAM);
}
break;
case RSTREAM:
{
setState(1477);
((InsertIntoExprContext)_localctx).r = match(RSTREAM);
}
break;
case IRSTREAM:
{
setState(1478);
((InsertIntoExprContext)_localctx).ir = match(IRSTREAM);
}
break;
case INTO:
break;
default:
break;
}
setState(1481);
match(INTO);
setState(1482);
classIdentifier();
setState(1488);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1483);
match(LPAREN);
setState(1485);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1484);
columnList();
}
}
setState(1487);
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 IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterColumnList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitColumnList(this);
}
}
public final ColumnListContext columnList() throws RecognitionException {
ColumnListContext _localctx = new ColumnListContext(_ctx, getState());
enterRule(_localctx, 178, RULE_columnList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1490);
match(IDENT);
setState(1495);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1491);
match(COMMA);
setState(1492);
match(IDENT);
}
}
}
setState(1497);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_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, 180, RULE_fromClause);
paraphrases.push("from clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1498);
streamExpression();
setState(1501);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EOF:
case WHERE:
case GROUP:
case HAVING:
case OUTPUT:
case ORDER:
case ROW_LIMIT_EXPR:
case MATCH_RECOGNIZE:
case FOR:
case RPAREN:
case COMMA:
{
setState(1499);
regularJoin();
}
break;
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
{
setState(1500);
outerJoinList();
}
break;
default:
throw new NoViableAltException(this);
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegularJoinContext extends ParserRuleContext {
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List streamExpression() {
return getRuleContexts(StreamExpressionContext.class);
}
public StreamExpressionContext streamExpression(int i) {
return getRuleContext(StreamExpressionContext.class,i);
}
public RegularJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regularJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRegularJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRegularJoin(this);
}
}
public final RegularJoinContext regularJoin() throws RecognitionException {
RegularJoinContext _localctx = new RegularJoinContext(_ctx, getState());
enterRule(_localctx, 182, RULE_regularJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1507);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1503);
match(COMMA);
setState(1504);
streamExpression();
}
}
setState(1509);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinListContext extends ParserRuleContext {
public List outerJoin() {
return getRuleContexts(OuterJoinContext.class);
}
public OuterJoinContext outerJoin(int i) {
return getRuleContext(OuterJoinContext.class,i);
}
public OuterJoinListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoinList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOuterJoinList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOuterJoinList(this);
}
}
public final OuterJoinListContext outerJoinList() throws RecognitionException {
OuterJoinListContext _localctx = new OuterJoinListContext(_ctx, getState());
enterRule(_localctx, 184, RULE_outerJoinList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1510);
outerJoin();
setState(1514);
_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(1511);
outerJoin();
}
}
setState(1516);
_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, 186, RULE_outerJoin);
paraphrases.push("outer join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1526);
_errHandler.sync(this);
switch (_input.LA(1)) {
case JOIN:
case LEFT:
case RIGHT:
case FULL:
{
setState(1523);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEFT) | (1L << RIGHT) | (1L << FULL))) != 0)) {
{
setState(1520);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LEFT:
{
setState(1517);
((OuterJoinContext)_localctx).tl = match(LEFT);
}
break;
case RIGHT:
{
setState(1518);
((OuterJoinContext)_localctx).tr = match(RIGHT);
}
break;
case FULL:
{
setState(1519);
((OuterJoinContext)_localctx).tf = match(FULL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1522);
match(OUTER);
}
}
}
break;
case INNER:
{
{
setState(1525);
((OuterJoinContext)_localctx).i = match(INNER);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1528);
match(JOIN);
setState(1529);
streamExpression();
setState(1531);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1530);
outerJoinIdent();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinIdentContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(EsperEPL2GrammarParser.ON, 0); }
public List outerJoinIdentPair() {
return getRuleContexts(OuterJoinIdentPairContext.class);
}
public OuterJoinIdentPairContext outerJoinIdentPair(int i) {
return getRuleContext(OuterJoinIdentPairContext.class,i);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public OuterJoinIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoinIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOuterJoinIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOuterJoinIdent(this);
}
}
public final OuterJoinIdentContext outerJoinIdent() throws RecognitionException {
OuterJoinIdentContext _localctx = new OuterJoinIdentContext(_ctx, getState());
enterRule(_localctx, 188, RULE_outerJoinIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1533);
match(ON);
setState(1534);
outerJoinIdentPair();
setState(1539);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR) {
{
{
setState(1535);
match(AND_EXPR);
setState(1536);
outerJoinIdentPair();
}
}
setState(1541);
_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 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, 190, RULE_outerJoinIdentPair);
try {
enterOuterAlt(_localctx, 1);
{
setState(1542);
eventProperty();
setState(1543);
match(EQUALS);
setState(1544);
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, 192, RULE_whereClause);
paraphrases.push("where clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1546);
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, 194, RULE_selectClause);
paraphrases.push("select clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1551);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(1548);
((SelectClauseContext)_localctx).s = match(RSTREAM);
}
break;
case 2:
{
setState(1549);
((SelectClauseContext)_localctx).s = match(ISTREAM);
}
break;
case 3:
{
setState(1550);
((SelectClauseContext)_localctx).s = match(IRSTREAM);
}
break;
}
setState(1554);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1553);
((SelectClauseContext)_localctx).d = match(DISTINCT);
}
}
setState(1556);
selectionList();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectionListContext extends ParserRuleContext {
public List selectionListElement() {
return getRuleContexts(SelectionListElementContext.class);
}
public SelectionListElementContext selectionListElement(int i) {
return getRuleContext(SelectionListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public SelectionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSelectionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSelectionList(this);
}
}
public final SelectionListContext selectionList() throws RecognitionException {
SelectionListContext _localctx = new SelectionListContext(_ctx, getState());
enterRule(_localctx, 196, RULE_selectionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1558);
selectionListElement();
setState(1563);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1559);
match(COMMA);
setState(1560);
selectionListElement();
}
}
setState(1565);
_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, 198, RULE_selectionListElement);
try {
setState(1569);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1566);
((SelectionListElementContext)_localctx).s = match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1567);
streamSelector();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1568);
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, 200, RULE_selectionListElementExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1571);
expression();
setState(1573);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1572);
selectionListElementAnno();
}
}
setState(1579);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
case 1:
{
setState(1576);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1575);
match(AS);
}
}
setState(1578);
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, 202, RULE_selectionListElementAnno);
try {
enterOuterAlt(_localctx, 1);
{
setState(1581);
match(ATCHAR);
setState(1582);
((SelectionListElementAnnoContext)_localctx).i = match(IDENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamSelectorContext extends ParserRuleContext {
public Token s;
public Token i;
public TerminalNode DOT() { return getToken(EsperEPL2GrammarParser.DOT, 0); }
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public StreamSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_streamSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStreamSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStreamSelector(this);
}
}
public final StreamSelectorContext streamSelector() throws RecognitionException {
StreamSelectorContext _localctx = new StreamSelectorContext(_ctx, getState());
enterRule(_localctx, 204, RULE_streamSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1584);
((StreamSelectorContext)_localctx).s = match(IDENT);
setState(1585);
match(DOT);
setState(1586);
match(STAR);
setState(1589);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1587);
match(AS);
setState(1588);
((StreamSelectorContext)_localctx).i = match(IDENT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamExpressionContext extends ParserRuleContext {
public Token u;
public Token ru;
public Token ri;
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public PatternInclusionExpressionContext patternInclusionExpression() {
return getRuleContext(PatternInclusionExpressionContext.class,0);
}
public DatabaseJoinExpressionContext databaseJoinExpression() {
return getRuleContext(DatabaseJoinExpressionContext.class,0);
}
public MethodJoinExpressionContext methodJoinExpression() {
return getRuleContext(MethodJoinExpressionContext.class,0);
}
public ViewExpressionsContext viewExpressions() {
return getRuleContext(ViewExpressionsContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode UNIDIRECTIONAL() { return getToken(EsperEPL2GrammarParser.UNIDIRECTIONAL, 0); }
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public StreamExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_streamExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterStreamExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitStreamExpression(this);
}
}
public final StreamExpressionContext streamExpression() throws RecognitionException {
StreamExpressionContext _localctx = new StreamExpressionContext(_ctx, getState());
enterRule(_localctx, 206, RULE_streamExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1595);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
{
setState(1591);
eventFilterExpression();
}
break;
case 2:
{
setState(1592);
patternInclusionExpression();
}
break;
case 3:
{
setState(1593);
databaseJoinExpression();
}
break;
case 4:
{
setState(1594);
methodJoinExpression();
}
break;
}
setState(1598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(1597);
viewExpressions();
}
}
setState(1603);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(1600);
match(AS);
setState(1601);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(1602);
identOrTicked();
}
break;
case EOF:
case WHERE:
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case ON:
case GROUP:
case HAVING:
case OUTPUT:
case ORDER:
case UNIDIRECTIONAL:
case RETAINUNION:
case RETAININTERSECTION:
case ROW_LIMIT_EXPR:
case MATCH_RECOGNIZE:
case FOR:
case RPAREN:
case COMMA:
break;
default:
break;
}
setState(1606);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNIDIRECTIONAL) {
{
setState(1605);
((StreamExpressionContext)_localctx).u = match(UNIDIRECTIONAL);
}
}
setState(1610);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(1608);
((StreamExpressionContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(1609);
((StreamExpressionContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case EOF:
case WHERE:
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case FULL:
case ON:
case GROUP:
case HAVING:
case OUTPUT:
case ORDER:
case ROW_LIMIT_EXPR:
case MATCH_RECOGNIZE:
case FOR:
case RPAREN:
case COMMA:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForExprContext extends ParserRuleContext {
public Token i;
public TerminalNode FOR() { return getToken(EsperEPL2GrammarParser.FOR, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ForExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterForExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitForExpr(this);
}
}
public final ForExprContext forExpr() throws RecognitionException {
ForExprContext _localctx = new ForExprContext(_ctx, getState());
enterRule(_localctx, 208, RULE_forExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1612);
match(FOR);
setState(1613);
((ForExprContext)_localctx).i = match(IDENT);
setState(1619);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1614);
match(LPAREN);
setState(1616);
_errHandler.sync(this);
_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(1615);
expressionList();
}
}
setState(1618);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternInclusionExpressionContext extends ParserRuleContext {
public TerminalNode PATTERN() { return getToken(EsperEPL2GrammarParser.PATTERN, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public PatternExpressionContext patternExpression() {
return getRuleContext(PatternExpressionContext.class,0);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List annotationEnum() {
return getRuleContexts(AnnotationEnumContext.class);
}
public AnnotationEnumContext annotationEnum(int i) {
return getRuleContext(AnnotationEnumContext.class,i);
}
public PatternInclusionExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternInclusionExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPatternInclusionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPatternInclusionExpression(this);
}
}
public final PatternInclusionExpressionContext patternInclusionExpression() throws RecognitionException {
PatternInclusionExpressionContext _localctx = new PatternInclusionExpressionContext(_ctx, getState());
enterRule(_localctx, 210, RULE_patternInclusionExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1621);
match(PATTERN);
setState(1625);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ATCHAR) {
{
{
setState(1622);
annotationEnum();
}
}
setState(1627);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1628);
match(LBRACK);
setState(1629);
patternExpression();
setState(1630);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DatabaseJoinExpressionContext extends ParserRuleContext {
public Token i;
public Token s;
public Token s2;
public TerminalNode SQL() { return getToken(EsperEPL2GrammarParser.SQL, 0); }
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public List STRING_LITERAL() { return getTokens(EsperEPL2GrammarParser.STRING_LITERAL); }
public TerminalNode STRING_LITERAL(int i) {
return getToken(EsperEPL2GrammarParser.STRING_LITERAL, i);
}
public List QUOTED_STRING_LITERAL() { return getTokens(EsperEPL2GrammarParser.QUOTED_STRING_LITERAL); }
public TerminalNode QUOTED_STRING_LITERAL(int i) {
return getToken(EsperEPL2GrammarParser.QUOTED_STRING_LITERAL, i);
}
public TerminalNode METADATASQL() { return getToken(EsperEPL2GrammarParser.METADATASQL, 0); }
public DatabaseJoinExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_databaseJoinExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDatabaseJoinExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDatabaseJoinExpression(this);
}
}
public final DatabaseJoinExpressionContext databaseJoinExpression() throws RecognitionException {
DatabaseJoinExpressionContext _localctx = new DatabaseJoinExpressionContext(_ctx, getState());
enterRule(_localctx, 212, RULE_databaseJoinExpression);
paraphrases.push("relational data join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1632);
match(SQL);
setState(1633);
match(COLON);
setState(1634);
((DatabaseJoinExpressionContext)_localctx).i = match(IDENT);
setState(1635);
match(LBRACK);
setState(1638);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(1636);
((DatabaseJoinExpressionContext)_localctx).s = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(1637);
((DatabaseJoinExpressionContext)_localctx).s = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1645);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==METADATASQL) {
{
setState(1640);
match(METADATASQL);
setState(1643);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(1641);
((DatabaseJoinExpressionContext)_localctx).s2 = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(1642);
((DatabaseJoinExpressionContext)_localctx).s2 = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(1647);
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, 214, RULE_methodJoinExpression);
paraphrases.push("method invocation join");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1649);
((MethodJoinExpressionContext)_localctx).i = match(IDENT);
setState(1650);
match(COLON);
setState(1651);
classIdentifier();
setState(1657);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1652);
match(LPAREN);
setState(1654);
_errHandler.sync(this);
_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(1653);
expressionList();
}
}
setState(1656);
match(RPAREN);
}
}
setState(1660);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(1659);
typeExpressionAnnotation();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ViewExpressionsContext extends ParserRuleContext {
public List DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public List viewExpressionWNamespace() {
return getRuleContexts(ViewExpressionWNamespaceContext.class);
}
public ViewExpressionWNamespaceContext viewExpressionWNamespace(int i) {
return getRuleContext(ViewExpressionWNamespaceContext.class,i);
}
public List HASHCHAR() { return getTokens(EsperEPL2GrammarParser.HASHCHAR); }
public TerminalNode HASHCHAR(int i) {
return getToken(EsperEPL2GrammarParser.HASHCHAR, i);
}
public List viewExpressionOptNamespace() {
return getRuleContexts(ViewExpressionOptNamespaceContext.class);
}
public ViewExpressionOptNamespaceContext viewExpressionOptNamespace(int i) {
return getRuleContext(ViewExpressionOptNamespaceContext.class,i);
}
public ViewExpressionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_viewExpressions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterViewExpressions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitViewExpressions(this);
}
}
public final ViewExpressionsContext viewExpressions() throws RecognitionException {
ViewExpressionsContext _localctx = new ViewExpressionsContext(_ctx, getState());
enterRule(_localctx, 216, RULE_viewExpressions);
paraphrases.push("view specifications");
int _la;
try {
setState(1680);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DOT:
enterOuterAlt(_localctx, 1);
{
{
setState(1662);
match(DOT);
setState(1663);
viewExpressionWNamespace();
setState(1668);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1664);
match(DOT);
setState(1665);
viewExpressionWNamespace();
}
}
setState(1670);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case HASHCHAR:
enterOuterAlt(_localctx, 2);
{
{
setState(1671);
match(HASHCHAR);
setState(1672);
viewExpressionOptNamespace();
setState(1677);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==HASHCHAR) {
{
{
setState(1673);
match(HASHCHAR);
setState(1674);
viewExpressionOptNamespace();
}
}
setState(1679);
_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, 218, RULE_viewExpressionWNamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1682);
((ViewExpressionWNamespaceContext)_localctx).ns = match(IDENT);
setState(1683);
match(COLON);
setState(1684);
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, 220, RULE_viewExpressionOptNamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1688);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
{
setState(1686);
((ViewExpressionOptNamespaceContext)_localctx).ns = match(IDENT);
setState(1687);
match(COLON);
}
break;
}
setState(1690);
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, 222, RULE_viewWParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1694);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(1692);
((ViewWParametersContext)_localctx).i = match(IDENT);
}
break;
case MERGE:
{
setState(1693);
((ViewWParametersContext)_localctx).m = match(MERGE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1701);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
{
setState(1696);
match(LPAREN);
setState(1698);
_errHandler.sync(this);
_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(1697);
expressionWithTimeList();
}
}
setState(1700);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByListExprContext extends ParserRuleContext {
public List groupByListChoice() {
return getRuleContexts(GroupByListChoiceContext.class);
}
public GroupByListChoiceContext groupByListChoice(int i) {
return getRuleContext(GroupByListChoiceContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByListExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByListExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByListExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByListExpr(this);
}
}
public final GroupByListExprContext groupByListExpr() throws RecognitionException {
GroupByListExprContext _localctx = new GroupByListExprContext(_ctx, getState());
enterRule(_localctx, 224, RULE_groupByListExpr);
paraphrases.push("group-by clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1703);
groupByListChoice();
setState(1708);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1704);
match(COMMA);
setState(1705);
groupByListChoice();
}
}
setState(1710);
_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, 226, RULE_groupByListChoice);
try {
setState(1714);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1711);
((GroupByListChoiceContext)_localctx).e1 = expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1712);
groupByCubeOrRollup();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1713);
groupByGroupingSets();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByCubeOrRollupContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List groupByCombinableExpr() {
return getRuleContexts(GroupByCombinableExprContext.class);
}
public GroupByCombinableExprContext groupByCombinableExpr(int i) {
return getRuleContext(GroupByCombinableExprContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode CUBE() { return getToken(EsperEPL2GrammarParser.CUBE, 0); }
public TerminalNode ROLLUP() { return getToken(EsperEPL2GrammarParser.ROLLUP, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByCubeOrRollupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByCubeOrRollup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByCubeOrRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByCubeOrRollup(this);
}
}
public final GroupByCubeOrRollupContext groupByCubeOrRollup() throws RecognitionException {
GroupByCubeOrRollupContext _localctx = new GroupByCubeOrRollupContext(_ctx, getState());
enterRule(_localctx, 228, RULE_groupByCubeOrRollup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1716);
_la = _input.LA(1);
if ( !(_la==CUBE || _la==ROLLUP) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1717);
match(LPAREN);
setState(1718);
groupByCombinableExpr();
setState(1723);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1719);
match(COMMA);
setState(1720);
groupByCombinableExpr();
}
}
setState(1725);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1726);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByGroupingSetsContext extends ParserRuleContext {
public TerminalNode GROUPING() { return getToken(EsperEPL2GrammarParser.GROUPING, 0); }
public TerminalNode SETS() { return getToken(EsperEPL2GrammarParser.SETS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List groupBySetsChoice() {
return getRuleContexts(GroupBySetsChoiceContext.class);
}
public GroupBySetsChoiceContext groupBySetsChoice(int i) {
return getRuleContext(GroupBySetsChoiceContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByGroupingSetsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByGroupingSets; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByGroupingSets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByGroupingSets(this);
}
}
public final GroupByGroupingSetsContext groupByGroupingSets() throws RecognitionException {
GroupByGroupingSetsContext _localctx = new GroupByGroupingSetsContext(_ctx, getState());
enterRule(_localctx, 230, RULE_groupByGroupingSets);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1728);
match(GROUPING);
setState(1729);
match(SETS);
setState(1730);
match(LPAREN);
setState(1731);
groupBySetsChoice();
setState(1736);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1732);
match(COMMA);
setState(1733);
groupBySetsChoice();
}
}
setState(1738);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1739);
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, 232, RULE_groupBySetsChoice);
try {
setState(1743);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CUBE:
case ROLLUP:
enterOuterAlt(_localctx, 1);
{
setState(1741);
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(1742);
groupByCombinableExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByCombinableExprContext extends ParserRuleContext {
public ExpressionContext e1;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public GroupByCombinableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByCombinableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGroupByCombinableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGroupByCombinableExpr(this);
}
}
public final GroupByCombinableExprContext groupByCombinableExpr() throws RecognitionException {
GroupByCombinableExprContext _localctx = new GroupByCombinableExprContext(_ctx, getState());
enterRule(_localctx, 234, RULE_groupByCombinableExpr);
int _la;
try {
setState(1758);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1745);
((GroupByCombinableExprContext)_localctx).e1 = expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1746);
match(LPAREN);
setState(1755);
_errHandler.sync(this);
_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(1747);
expression();
setState(1752);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1748);
match(COMMA);
setState(1749);
expression();
}
}
setState(1754);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1757);
match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByListExprContext extends ParserRuleContext {
public List orderByListElement() {
return getRuleContexts(OrderByListElementContext.class);
}
public OrderByListElementContext orderByListElement(int i) {
return getRuleContext(OrderByListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public OrderByListExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByListExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOrderByListExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOrderByListExpr(this);
}
}
public final OrderByListExprContext orderByListExpr() throws RecognitionException {
OrderByListExprContext _localctx = new OrderByListExprContext(_ctx, getState());
enterRule(_localctx, 236, RULE_orderByListExpr);
paraphrases.push("order by clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1760);
orderByListElement();
setState(1765);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1761);
match(COMMA);
setState(1762);
orderByListElement();
}
}
setState(1767);
_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, 238, RULE_orderByListElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1768);
expression();
setState(1771);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASC:
{
setState(1769);
((OrderByListElementContext)_localctx).a = match(ASC);
}
break;
case DESC:
{
setState(1770);
((OrderByListElementContext)_localctx).d = match(DESC);
}
break;
case EOF:
case INSERT:
case ROW_LIMIT_EXPR:
case FOR:
case RPAREN:
case COMMA:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public EvalOrExpressionContext evalOrExpression() {
return getRuleContext(EvalOrExpressionContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitHavingClause(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 240, RULE_havingClause);
paraphrases.push("having clause");
try {
enterOuterAlt(_localctx, 1);
{
setState(1773);
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, 242, RULE_outputLimit);
paraphrases.push("output rate clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1776);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER) {
{
setState(1775);
outputLimitAfter();
}
}
setState(1782);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
{
setState(1778);
((OutputLimitContext)_localctx).k = match(ALL);
}
break;
case FIRST:
{
setState(1779);
((OutputLimitContext)_localctx).k = match(FIRST);
}
break;
case LAST:
{
setState(1780);
((OutputLimitContext)_localctx).k = match(LAST);
}
break;
case SNAPSHOT:
{
setState(1781);
((OutputLimitContext)_localctx).k = match(SNAPSHOT);
}
break;
case EOF:
case AND_EXPR:
case EVERY_EXPR:
case WHEN:
case ORDER:
case AT:
case ROW_LIMIT_EXPR:
case FOR:
case RPAREN:
break;
default:
break;
}
setState(1812);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) {
case 1:
{
{
setState(1784);
((OutputLimitContext)_localctx).ev = match(EVERY_EXPR);
setState(1791);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) {
case 1:
{
setState(1785);
timePeriod();
}
break;
case 2:
{
setState(1788);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1786);
number();
}
break;
case IDENT:
{
setState(1787);
((OutputLimitContext)_localctx).i = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
{
setState(1790);
((OutputLimitContext)_localctx).e = match(EVENTS);
}
}
break;
}
}
}
break;
case 2:
{
{
setState(1793);
((OutputLimitContext)_localctx).at = match(AT);
setState(1794);
crontabLimitParameterSet();
}
}
break;
case 3:
{
{
setState(1795);
((OutputLimitContext)_localctx).wh = match(WHEN);
setState(1796);
expression();
setState(1799);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1797);
match(THEN);
setState(1798);
onSetExpr();
}
}
}
}
break;
case 4:
{
{
setState(1801);
((OutputLimitContext)_localctx).t = match(WHEN);
setState(1802);
match(TERMINATED);
setState(1805);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,222,_ctx) ) {
case 1:
{
setState(1803);
match(AND_EXPR);
setState(1804);
expression();
}
break;
}
setState(1809);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1807);
match(THEN);
setState(1808);
onSetExpr();
}
}
}
}
break;
case 5:
{
}
break;
}
setState(1815);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(1814);
outputLimitAndTerm();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputLimitAndTermContext extends ParserRuleContext {
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public TerminalNode TERMINATED() { return getToken(EsperEPL2GrammarParser.TERMINATED, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public OnSetExprContext onSetExpr() {
return getRuleContext(OnSetExprContext.class,0);
}
public OutputLimitAndTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputLimitAndTerm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOutputLimitAndTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOutputLimitAndTerm(this);
}
}
public final OutputLimitAndTermContext outputLimitAndTerm() throws RecognitionException {
OutputLimitAndTermContext _localctx = new OutputLimitAndTermContext(_ctx, getState());
enterRule(_localctx, 244, RULE_outputLimitAndTerm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1817);
match(AND_EXPR);
setState(1818);
match(WHEN);
setState(1819);
match(TERMINATED);
setState(1822);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND_EXPR) {
{
setState(1820);
match(AND_EXPR);
setState(1821);
expression();
}
}
setState(1826);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THEN) {
{
setState(1824);
match(THEN);
setState(1825);
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, 246, RULE_outputLimitAfter);
try {
enterOuterAlt(_localctx, 1);
{
setState(1828);
((OutputLimitAfterContext)_localctx).a = match(AFTER);
setState(1833);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
case 1:
{
setState(1829);
timePeriod();
}
break;
case 2:
{
setState(1830);
number();
setState(1831);
match(EVENTS);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RowLimitContext extends ParserRuleContext {
public NumberconstantContext n1;
public Token i1;
public Token c;
public Token o;
public NumberconstantContext n2;
public Token i2;
public List numberconstant() {
return getRuleContexts(NumberconstantContext.class);
}
public NumberconstantContext numberconstant(int i) {
return getRuleContext(NumberconstantContext.class,i);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public TerminalNode OFFSET() { return getToken(EsperEPL2GrammarParser.OFFSET, 0); }
public RowLimitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowLimit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRowLimit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRowLimit(this);
}
}
public final RowLimitContext rowLimit() throws RecognitionException {
RowLimitContext _localctx = new RowLimitContext(_ctx, getState());
enterRule(_localctx, 248, RULE_rowLimit);
paraphrases.push("row limit clause");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1837);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1835);
((RowLimitContext)_localctx).n1 = numberconstant();
}
break;
case IDENT:
{
setState(1836);
((RowLimitContext)_localctx).i1 = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1847);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFSET || _la==COMMA) {
{
setState(1841);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMA:
{
setState(1839);
((RowLimitContext)_localctx).c = match(COMMA);
}
break;
case OFFSET:
{
setState(1840);
((RowLimitContext)_localctx).o = match(OFFSET);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1845);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(1843);
((RowLimitContext)_localctx).n2 = numberconstant();
}
break;
case IDENT:
{
setState(1844);
((RowLimitContext)_localctx).i2 = match(IDENT);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CrontabLimitParameterSetListContext extends ParserRuleContext {
public List crontabLimitParameterSet() {
return getRuleContexts(CrontabLimitParameterSetContext.class);
}
public CrontabLimitParameterSetContext crontabLimitParameterSet(int i) {
return getRuleContext(CrontabLimitParameterSetContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public CrontabLimitParameterSetListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crontabLimitParameterSetList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCrontabLimitParameterSetList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCrontabLimitParameterSetList(this);
}
}
public final CrontabLimitParameterSetListContext crontabLimitParameterSetList() throws RecognitionException {
CrontabLimitParameterSetListContext _localctx = new CrontabLimitParameterSetListContext(_ctx, getState());
enterRule(_localctx, 250, RULE_crontabLimitParameterSetList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1849);
crontabLimitParameterSet();
setState(1854);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1850);
match(COMMA);
setState(1851);
crontabLimitParameterSet();
}
}
}
setState(1856);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CrontabLimitParameterSetContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionWithTimeListContext expressionWithTimeList() {
return getRuleContext(ExpressionWithTimeListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public CrontabLimitParameterSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crontabLimitParameterSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCrontabLimitParameterSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCrontabLimitParameterSet(this);
}
}
public final CrontabLimitParameterSetContext crontabLimitParameterSet() throws RecognitionException {
CrontabLimitParameterSetContext _localctx = new CrontabLimitParameterSetContext(_ctx, getState());
enterRule(_localctx, 252, RULE_crontabLimitParameterSet);
try {
enterOuterAlt(_localctx, 1);
{
setState(1857);
match(LPAREN);
setState(1858);
expressionWithTimeList();
setState(1859);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhenClauseContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(EsperEPL2GrammarParser.WHEN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode THEN() { return getToken(EsperEPL2GrammarParser.THEN, 0); }
public WhenClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whenClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterWhenClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitWhenClause(this);
}
}
public final WhenClauseContext whenClause() throws RecognitionException {
WhenClauseContext _localctx = new WhenClauseContext(_ctx, getState());
enterRule(_localctx, 254, RULE_whenClause);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1861);
match(WHEN);
setState(1862);
expression();
setState(1863);
match(THEN);
setState(1864);
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, 256, RULE_elseClause);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1866);
match(ELSE);
setState(1867);
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, 258, RULE_matchRecog);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1869);
match(MATCH_RECOGNIZE);
setState(1870);
match(LPAREN);
setState(1872);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1871);
matchRecogPartitionBy();
}
}
setState(1874);
matchRecogMeasures();
setState(1876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(1875);
matchRecogMatchesSelection();
}
}
setState(1879);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER) {
{
setState(1878);
matchRecogMatchesAfterSkip();
}
}
setState(1881);
matchRecogPattern();
setState(1883);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1882);
matchRecogMatchesInterval();
}
}
setState(1886);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFINE) {
{
setState(1885);
matchRecogDefine();
}
}
setState(1888);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPartitionByContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(EsperEPL2GrammarParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(EsperEPL2GrammarParser.BY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogPartitionByContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPartitionBy; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPartitionBy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPartitionBy(this);
}
}
public final MatchRecogPartitionByContext matchRecogPartitionBy() throws RecognitionException {
MatchRecogPartitionByContext _localctx = new MatchRecogPartitionByContext(_ctx, getState());
enterRule(_localctx, 260, RULE_matchRecogPartitionBy);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1890);
match(PARTITION);
setState(1891);
match(BY);
setState(1892);
expression();
setState(1897);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1893);
match(COMMA);
setState(1894);
expression();
}
}
setState(1899);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMeasuresContext extends ParserRuleContext {
public TerminalNode MEASURES() { return getToken(EsperEPL2GrammarParser.MEASURES, 0); }
public List matchRecogMeasureItem() {
return getRuleContexts(MatchRecogMeasureItemContext.class);
}
public MatchRecogMeasureItemContext matchRecogMeasureItem(int i) {
return getRuleContext(MatchRecogMeasureItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogMeasuresContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMeasures; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMeasures(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMeasures(this);
}
}
public final MatchRecogMeasuresContext matchRecogMeasures() throws RecognitionException {
MatchRecogMeasuresContext _localctx = new MatchRecogMeasuresContext(_ctx, getState());
enterRule(_localctx, 262, RULE_matchRecogMeasures);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1900);
match(MEASURES);
setState(1901);
matchRecogMeasureItem();
setState(1906);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1902);
match(COMMA);
setState(1903);
matchRecogMeasureItem();
}
}
setState(1908);
_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, 264, RULE_matchRecogMeasureItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1909);
expression();
setState(1914);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1910);
match(AS);
setState(1912);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(1911);
((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, 266, RULE_matchRecogMatchesSelection);
try {
enterOuterAlt(_localctx, 1);
{
setState(1916);
match(ALL);
setState(1917);
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, 268, RULE_matchRecogPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(1919);
match(PATTERN);
setState(1920);
match(LPAREN);
setState(1921);
matchRecogPatternAlteration();
setState(1922);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogMatchesAfterSkipContext extends ParserRuleContext {
public KeywordAllowedIdentContext i1;
public KeywordAllowedIdentContext i2;
public KeywordAllowedIdentContext i3;
public KeywordAllowedIdentContext i4;
public KeywordAllowedIdentContext i5;
public TerminalNode AFTER() { return getToken(EsperEPL2GrammarParser.AFTER, 0); }
public List keywordAllowedIdent() {
return getRuleContexts(KeywordAllowedIdentContext.class);
}
public KeywordAllowedIdentContext keywordAllowedIdent(int i) {
return getRuleContext(KeywordAllowedIdentContext.class,i);
}
public MatchRecogMatchesAfterSkipContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogMatchesAfterSkip; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogMatchesAfterSkip(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogMatchesAfterSkip(this);
}
}
public final MatchRecogMatchesAfterSkipContext matchRecogMatchesAfterSkip() throws RecognitionException {
MatchRecogMatchesAfterSkipContext _localctx = new MatchRecogMatchesAfterSkipContext(_ctx, getState());
enterRule(_localctx, 270, RULE_matchRecogMatchesAfterSkip);
try {
enterOuterAlt(_localctx, 1);
{
setState(1924);
match(AFTER);
setState(1925);
((MatchRecogMatchesAfterSkipContext)_localctx).i1 = keywordAllowedIdent();
setState(1926);
((MatchRecogMatchesAfterSkipContext)_localctx).i2 = keywordAllowedIdent();
setState(1927);
((MatchRecogMatchesAfterSkipContext)_localctx).i3 = keywordAllowedIdent();
setState(1928);
((MatchRecogMatchesAfterSkipContext)_localctx).i4 = keywordAllowedIdent();
setState(1929);
((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, 272, RULE_matchRecogMatchesInterval);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1931);
((MatchRecogMatchesIntervalContext)_localctx).i = match(IDENT);
setState(1932);
timePeriod();
setState(1935);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR_EXPR) {
{
setState(1933);
match(OR_EXPR);
setState(1934);
((MatchRecogMatchesIntervalContext)_localctx).t = match(TERMINATED);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternAlterationContext extends ParserRuleContext {
public Token o;
public List matchRecogPatternConcat() {
return getRuleContexts(MatchRecogPatternConcatContext.class);
}
public MatchRecogPatternConcatContext matchRecogPatternConcat(int i) {
return getRuleContext(MatchRecogPatternConcatContext.class,i);
}
public List BOR() { return getTokens(EsperEPL2GrammarParser.BOR); }
public TerminalNode BOR(int i) {
return getToken(EsperEPL2GrammarParser.BOR, i);
}
public MatchRecogPatternAlterationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternAlteration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternAlteration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternAlteration(this);
}
}
public final MatchRecogPatternAlterationContext matchRecogPatternAlteration() throws RecognitionException {
MatchRecogPatternAlterationContext _localctx = new MatchRecogPatternAlterationContext(_ctx, getState());
enterRule(_localctx, 274, RULE_matchRecogPatternAlteration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1937);
matchRecogPatternConcat();
setState(1942);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BOR) {
{
{
setState(1938);
((MatchRecogPatternAlterationContext)_localctx).o = match(BOR);
setState(1939);
matchRecogPatternConcat();
}
}
setState(1944);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternConcatContext extends ParserRuleContext {
public List matchRecogPatternUnary() {
return getRuleContexts(MatchRecogPatternUnaryContext.class);
}
public MatchRecogPatternUnaryContext matchRecogPatternUnary(int i) {
return getRuleContext(MatchRecogPatternUnaryContext.class,i);
}
public MatchRecogPatternConcatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternConcat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternConcat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternConcat(this);
}
}
public final MatchRecogPatternConcatContext matchRecogPatternConcat() throws RecognitionException {
MatchRecogPatternConcatContext _localctx = new MatchRecogPatternConcatContext(_ctx, getState());
enterRule(_localctx, 276, RULE_matchRecogPatternConcat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1946);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1945);
matchRecogPatternUnary();
}
}
setState(1948);
_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, 278, RULE_matchRecogPatternUnary);
try {
setState(1953);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MATCH_RECOGNIZE_PERMUTE:
enterOuterAlt(_localctx, 1);
{
setState(1950);
matchRecogPatternPermute();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(1951);
matchRecogPatternNested();
}
break;
case IDENT:
enterOuterAlt(_localctx, 3);
{
setState(1952);
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, 280, RULE_matchRecogPatternNested);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1955);
match(LPAREN);
setState(1956);
matchRecogPatternAlteration();
setState(1957);
match(RPAREN);
setState(1961);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(1958);
((MatchRecogPatternNestedContext)_localctx).s = match(STAR);
}
break;
case PLUS:
{
setState(1959);
((MatchRecogPatternNestedContext)_localctx).s = match(PLUS);
}
break;
case QUESTION:
{
setState(1960);
((MatchRecogPatternNestedContext)_localctx).s = match(QUESTION);
}
break;
case MATCH_RECOGNIZE_PERMUTE:
case LPAREN:
case RPAREN:
case LCURLY:
case COMMA:
case BOR:
case IDENT:
break;
default:
break;
}
setState(1964);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(1963);
matchRecogPatternRepeat();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternPermuteContext extends ParserRuleContext {
public TerminalNode MATCH_RECOGNIZE_PERMUTE() { return getToken(EsperEPL2GrammarParser.MATCH_RECOGNIZE_PERMUTE, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List matchRecogPatternAlteration() {
return getRuleContexts(MatchRecogPatternAlterationContext.class);
}
public MatchRecogPatternAlterationContext matchRecogPatternAlteration(int i) {
return getRuleContext(MatchRecogPatternAlterationContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogPatternPermuteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternPermute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternPermute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternPermute(this);
}
}
public final MatchRecogPatternPermuteContext matchRecogPatternPermute() throws RecognitionException {
MatchRecogPatternPermuteContext _localctx = new MatchRecogPatternPermuteContext(_ctx, getState());
enterRule(_localctx, 282, RULE_matchRecogPatternPermute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1966);
match(MATCH_RECOGNIZE_PERMUTE);
setState(1967);
match(LPAREN);
setState(1968);
matchRecogPatternAlteration();
setState(1973);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1969);
match(COMMA);
setState(1970);
matchRecogPatternAlteration();
}
}
setState(1975);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1976);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternAtomContext extends ParserRuleContext {
public Token i;
public Token s;
public Token reluctant;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MatchRecogPatternRepeatContext matchRecogPatternRepeat() {
return getRuleContext(MatchRecogPatternRepeatContext.class,0);
}
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public TerminalNode PLUS() { return getToken(EsperEPL2GrammarParser.PLUS, 0); }
public List QUESTION() { return getTokens(EsperEPL2GrammarParser.QUESTION); }
public TerminalNode QUESTION(int i) {
return getToken(EsperEPL2GrammarParser.QUESTION, i);
}
public MatchRecogPatternAtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternAtom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternAtom(this);
}
}
public final MatchRecogPatternAtomContext matchRecogPatternAtom() throws RecognitionException {
MatchRecogPatternAtomContext _localctx = new MatchRecogPatternAtomContext(_ctx, getState());
enterRule(_localctx, 284, RULE_matchRecogPatternAtom);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1978);
((MatchRecogPatternAtomContext)_localctx).i = match(IDENT);
setState(1987);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & ((1L << (QUESTION - 143)) | (1L << (PLUS - 143)) | (1L << (STAR - 143)))) != 0)) {
{
setState(1982);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(1979);
((MatchRecogPatternAtomContext)_localctx).s = match(STAR);
}
break;
case PLUS:
{
setState(1980);
((MatchRecogPatternAtomContext)_localctx).s = match(PLUS);
}
break;
case QUESTION:
{
setState(1981);
((MatchRecogPatternAtomContext)_localctx).s = match(QUESTION);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1985);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUESTION) {
{
setState(1984);
((MatchRecogPatternAtomContext)_localctx).reluctant = match(QUESTION);
}
}
}
}
setState(1990);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LCURLY) {
{
setState(1989);
matchRecogPatternRepeat();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogPatternRepeatContext extends ParserRuleContext {
public ExpressionContext e1;
public Token comma;
public ExpressionContext e2;
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode COMMA() { return getToken(EsperEPL2GrammarParser.COMMA, 0); }
public MatchRecogPatternRepeatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogPatternRepeat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogPatternRepeat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogPatternRepeat(this);
}
}
public final MatchRecogPatternRepeatContext matchRecogPatternRepeat() throws RecognitionException {
MatchRecogPatternRepeatContext _localctx = new MatchRecogPatternRepeatContext(_ctx, getState());
enterRule(_localctx, 286, RULE_matchRecogPatternRepeat);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1992);
match(LCURLY);
setState(1994);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,254,_ctx) ) {
case 1:
{
setState(1993);
((MatchRecogPatternRepeatContext)_localctx).e1 = expression();
}
break;
}
setState(1997);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1996);
((MatchRecogPatternRepeatContext)_localctx).comma = match(COMMA);
}
}
setState(2000);
_errHandler.sync(this);
_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(1999);
((MatchRecogPatternRepeatContext)_localctx).e2 = expression();
}
}
setState(2002);
match(RCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchRecogDefineContext extends ParserRuleContext {
public TerminalNode DEFINE() { return getToken(EsperEPL2GrammarParser.DEFINE, 0); }
public List matchRecogDefineItem() {
return getRuleContexts(MatchRecogDefineItemContext.class);
}
public MatchRecogDefineItemContext matchRecogDefineItem(int i) {
return getRuleContext(MatchRecogDefineItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public MatchRecogDefineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchRecogDefine; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchRecogDefine(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchRecogDefine(this);
}
}
public final MatchRecogDefineContext matchRecogDefine() throws RecognitionException {
MatchRecogDefineContext _localctx = new MatchRecogDefineContext(_ctx, getState());
enterRule(_localctx, 288, RULE_matchRecogDefine);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2004);
match(DEFINE);
setState(2005);
matchRecogDefineItem();
setState(2010);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2006);
match(COMMA);
setState(2007);
matchRecogDefineItem();
}
}
setState(2012);
_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, 290, RULE_matchRecogDefineItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2013);
((MatchRecogDefineItemContext)_localctx).i = match(IDENT);
setState(2014);
match(AS);
setState(2015);
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, 292, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2017);
caseExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseExpressionContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(EsperEPL2GrammarParser.CASE, 0); }
public TerminalNode END() { return getToken(EsperEPL2GrammarParser.END, 0); }
public List whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public ElseClauseContext elseClause() {
return getRuleContext(ElseClauseContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public EvalOrExpressionContext evalOrExpression() {
return getRuleContext(EvalOrExpressionContext.class,0);
}
public CaseExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterCaseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitCaseExpression(this);
}
}
public final CaseExpressionContext caseExpression() throws RecognitionException {
CaseExpressionContext _localctx = new CaseExpressionContext(_ctx, getState());
enterRule(_localctx, 294, RULE_caseExpression);
int _la;
try {
setState(2047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
paraphrases.push("case expression");
setState(2020);
match(CASE);
setState(2022);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2021);
whenClause();
}
}
setState(2024);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(2027);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(2026);
elseClause();
}
}
setState(2029);
match(END);
paraphrases.pop();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
paraphrases.push("case expression");
setState(2033);
match(CASE);
setState(2034);
expression();
setState(2036);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2035);
whenClause();
}
}
setState(2038);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(2041);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(2040);
elseClause();
}
}
setState(2043);
match(END);
paraphrases.pop();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2046);
evalOrExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalOrExpressionContext extends ParserRuleContext {
public Token op;
public List evalAndExpression() {
return getRuleContexts(EvalAndExpressionContext.class);
}
public EvalAndExpressionContext evalAndExpression(int i) {
return getRuleContext(EvalAndExpressionContext.class,i);
}
public List OR_EXPR() { return getTokens(EsperEPL2GrammarParser.OR_EXPR); }
public TerminalNode OR_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.OR_EXPR, i);
}
public EvalOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalOrExpression(this);
}
}
public final EvalOrExpressionContext evalOrExpression() throws RecognitionException {
EvalOrExpressionContext _localctx = new EvalOrExpressionContext(_ctx, getState());
enterRule(_localctx, 296, RULE_evalOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2049);
evalAndExpression();
setState(2054);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_EXPR) {
{
{
setState(2050);
((EvalOrExpressionContext)_localctx).op = match(OR_EXPR);
setState(2051);
evalAndExpression();
}
}
setState(2056);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalAndExpressionContext extends ParserRuleContext {
public Token op;
public List bitWiseExpression() {
return getRuleContexts(BitWiseExpressionContext.class);
}
public BitWiseExpressionContext bitWiseExpression(int i) {
return getRuleContext(BitWiseExpressionContext.class,i);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public EvalAndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalAndExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalAndExpression(this);
}
}
public final EvalAndExpressionContext evalAndExpression() throws RecognitionException {
EvalAndExpressionContext _localctx = new EvalAndExpressionContext(_ctx, getState());
enterRule(_localctx, 298, RULE_evalAndExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2057);
bitWiseExpression();
setState(2062);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,264,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2058);
((EvalAndExpressionContext)_localctx).op = match(AND_EXPR);
setState(2059);
bitWiseExpression();
}
}
}
setState(2064);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,264,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitWiseExpressionContext extends ParserRuleContext {
public List negatedExpression() {
return getRuleContexts(NegatedExpressionContext.class);
}
public NegatedExpressionContext negatedExpression(int i) {
return getRuleContext(NegatedExpressionContext.class,i);
}
public List BAND() { return getTokens(EsperEPL2GrammarParser.BAND); }
public TerminalNode BAND(int i) {
return getToken(EsperEPL2GrammarParser.BAND, i);
}
public List BOR() { return getTokens(EsperEPL2GrammarParser.BOR); }
public TerminalNode BOR(int i) {
return getToken(EsperEPL2GrammarParser.BOR, i);
}
public List BXOR() { return getTokens(EsperEPL2GrammarParser.BXOR); }
public TerminalNode BXOR(int i) {
return getToken(EsperEPL2GrammarParser.BXOR, i);
}
public BitWiseExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitWiseExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBitWiseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBitWiseExpression(this);
}
}
public final BitWiseExpressionContext bitWiseExpression() throws RecognitionException {
BitWiseExpressionContext _localctx = new BitWiseExpressionContext(_ctx, getState());
enterRule(_localctx, 300, RULE_bitWiseExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2065);
negatedExpression();
setState(2070);
_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(2066);
_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 {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2067);
negatedExpression();
}
}
setState(2072);
_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, 302, RULE_negatedExpression);
try {
setState(2076);
_errHandler.sync(this);
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(2073);
evalEqualsExpression();
}
break;
case NOT_EXPR:
enterOuterAlt(_localctx, 2);
{
setState(2074);
match(NOT_EXPR);
setState(2075);
evalEqualsExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalEqualsExpressionContext extends ParserRuleContext {
public Token eq;
public Token is;
public Token isnot;
public Token sqlne;
public Token ne;
public Token a;
public List evalRelationalExpression() {
return getRuleContexts(EvalRelationalExpressionContext.class);
}
public EvalRelationalExpressionContext evalRelationalExpression(int i) {
return getRuleContext(EvalRelationalExpressionContext.class,i);
}
public List NOT_EXPR() { return getTokens(EsperEPL2GrammarParser.NOT_EXPR); }
public TerminalNode NOT_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.NOT_EXPR, i);
}
public List EQUALS() { return getTokens(EsperEPL2GrammarParser.EQUALS); }
public TerminalNode EQUALS(int i) {
return getToken(EsperEPL2GrammarParser.EQUALS, i);
}
public List IS() { return getTokens(EsperEPL2GrammarParser.IS); }
public TerminalNode IS(int i) {
return getToken(EsperEPL2GrammarParser.IS, i);
}
public List SQL_NE() { return getTokens(EsperEPL2GrammarParser.SQL_NE); }
public TerminalNode SQL_NE(int i) {
return getToken(EsperEPL2GrammarParser.SQL_NE, i);
}
public List NOT_EQUAL() { return getTokens(EsperEPL2GrammarParser.NOT_EQUAL); }
public TerminalNode NOT_EQUAL(int i) {
return getToken(EsperEPL2GrammarParser.NOT_EQUAL, i);
}
public List subSelectGroupExpression() {
return getRuleContexts(SubSelectGroupExpressionContext.class);
}
public SubSelectGroupExpressionContext subSelectGroupExpression(int i) {
return getRuleContext(SubSelectGroupExpressionContext.class,i);
}
public List ANY() { return getTokens(EsperEPL2GrammarParser.ANY); }
public TerminalNode ANY(int i) {
return getToken(EsperEPL2GrammarParser.ANY, i);
}
public List SOME() { return getTokens(EsperEPL2GrammarParser.SOME); }
public TerminalNode SOME(int i) {
return getToken(EsperEPL2GrammarParser.SOME, i);
}
public List ALL() { return getTokens(EsperEPL2GrammarParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(EsperEPL2GrammarParser.ALL, i);
}
public List LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public List RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public EvalEqualsExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalEqualsExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalEqualsExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalEqualsExpression(this);
}
}
public final EvalEqualsExpressionContext evalEqualsExpression() throws RecognitionException {
EvalEqualsExpressionContext _localctx = new EvalEqualsExpressionContext(_ctx, getState());
enterRule(_localctx, 304, RULE_evalEqualsExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2078);
evalRelationalExpression();
setState(2105);
_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(2085);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,267,_ctx) ) {
case 1:
{
setState(2079);
((EvalEqualsExpressionContext)_localctx).eq = match(EQUALS);
}
break;
case 2:
{
setState(2080);
((EvalEqualsExpressionContext)_localctx).is = match(IS);
}
break;
case 3:
{
setState(2081);
((EvalEqualsExpressionContext)_localctx).isnot = match(IS);
setState(2082);
match(NOT_EXPR);
}
break;
case 4:
{
setState(2083);
((EvalEqualsExpressionContext)_localctx).sqlne = match(SQL_NE);
}
break;
case 5:
{
setState(2084);
((EvalEqualsExpressionContext)_localctx).ne = match(NOT_EQUAL);
}
break;
}
setState(2101);
_errHandler.sync(this);
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(2087);
evalRelationalExpression();
}
break;
case ALL:
case ANY:
case SOME:
{
setState(2091);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ANY:
{
setState(2088);
((EvalEqualsExpressionContext)_localctx).a = match(ANY);
}
break;
case SOME:
{
setState(2089);
((EvalEqualsExpressionContext)_localctx).a = match(SOME);
}
break;
case ALL:
{
setState(2090);
((EvalEqualsExpressionContext)_localctx).a = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2099);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,270,_ctx) ) {
case 1:
{
{
setState(2093);
match(LPAREN);
setState(2095);
_errHandler.sync(this);
_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(2094);
expressionList();
}
}
setState(2097);
match(RPAREN);
}
}
break;
case 2:
{
setState(2098);
subSelectGroupExpression();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2107);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalRelationalExpressionContext extends ParserRuleContext {
public Token r;
public Token g;
public Token n;
public Token in;
public Token l;
public Token col;
public Token inset;
public Token between;
public Token like;
public Token regex;
public List concatenationExpr() {
return getRuleContexts(ConcatenationExprContext.class);
}
public ConcatenationExprContext concatenationExpr(int i) {
return getRuleContext(ConcatenationExprContext.class,i);
}
public InSubSelectQueryContext inSubSelectQuery() {
return getRuleContext(InSubSelectQueryContext.class,0);
}
public BetweenListContext betweenList() {
return getRuleContext(BetweenListContext.class,0);
}
public TerminalNode IN_SET() { return getToken(EsperEPL2GrammarParser.IN_SET, 0); }
public TerminalNode BETWEEN() { return getToken(EsperEPL2GrammarParser.BETWEEN, 0); }
public TerminalNode LIKE() { return getToken(EsperEPL2GrammarParser.LIKE, 0); }
public TerminalNode REGEXP() { return getToken(EsperEPL2GrammarParser.REGEXP, 0); }
public TerminalNode NOT_EXPR() { return getToken(EsperEPL2GrammarParser.NOT_EXPR, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ESCAPE() { return getToken(EsperEPL2GrammarParser.ESCAPE, 0); }
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public List LPAREN() { return getTokens(EsperEPL2GrammarParser.LPAREN); }
public TerminalNode LPAREN(int i) {
return getToken(EsperEPL2GrammarParser.LPAREN, i);
}
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List RPAREN() { return getTokens(EsperEPL2GrammarParser.RPAREN); }
public TerminalNode RPAREN(int i) {
return getToken(EsperEPL2GrammarParser.RPAREN, i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List LT() { return getTokens(EsperEPL2GrammarParser.LT); }
public TerminalNode LT(int i) {
return getToken(EsperEPL2GrammarParser.LT, i);
}
public List GT() { return getTokens(EsperEPL2GrammarParser.GT); }
public TerminalNode GT(int i) {
return getToken(EsperEPL2GrammarParser.GT, i);
}
public List LE() { return getTokens(EsperEPL2GrammarParser.LE); }
public TerminalNode LE(int i) {
return getToken(EsperEPL2GrammarParser.LE, i);
}
public List GE() { return getTokens(EsperEPL2GrammarParser.GE); }
public TerminalNode GE(int i) {
return getToken(EsperEPL2GrammarParser.GE, i);
}
public List subSelectGroupExpression() {
return getRuleContexts(SubSelectGroupExpressionContext.class);
}
public SubSelectGroupExpressionContext subSelectGroupExpression(int i) {
return getRuleContext(SubSelectGroupExpressionContext.class,i);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public List ANY() { return getTokens(EsperEPL2GrammarParser.ANY); }
public TerminalNode ANY(int i) {
return getToken(EsperEPL2GrammarParser.ANY, i);
}
public List SOME() { return getTokens(EsperEPL2GrammarParser.SOME); }
public TerminalNode SOME(int i) {
return getToken(EsperEPL2GrammarParser.SOME, i);
}
public List ALL() { return getTokens(EsperEPL2GrammarParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(EsperEPL2GrammarParser.ALL, i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List expressionList() {
return getRuleContexts(ExpressionListContext.class);
}
public ExpressionListContext expressionList(int i) {
return getRuleContext(ExpressionListContext.class,i);
}
public EvalRelationalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalRelationalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterEvalRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitEvalRelationalExpression(this);
}
}
public final EvalRelationalExpressionContext evalRelationalExpression() throws RecognitionException {
EvalRelationalExpressionContext _localctx = new EvalRelationalExpressionContext(_ctx, getState());
enterRule(_localctx, 306, RULE_evalRelationalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2108);
concatenationExpr();
setState(2174);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,286,_ctx) ) {
case 1:
{
{
setState(2133);
_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(2113);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LT:
{
setState(2109);
((EvalRelationalExpressionContext)_localctx).r = match(LT);
}
break;
case GT:
{
setState(2110);
((EvalRelationalExpressionContext)_localctx).r = match(GT);
}
break;
case LE:
{
setState(2111);
((EvalRelationalExpressionContext)_localctx).r = match(LE);
}
break;
case GE:
{
setState(2112);
((EvalRelationalExpressionContext)_localctx).r = match(GE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2129);
_errHandler.sync(this);
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(2115);
concatenationExpr();
}
break;
case ALL:
case ANY:
case SOME:
{
setState(2119);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ANY:
{
setState(2116);
((EvalRelationalExpressionContext)_localctx).g = match(ANY);
}
break;
case SOME:
{
setState(2117);
((EvalRelationalExpressionContext)_localctx).g = match(SOME);
}
break;
case ALL:
{
setState(2118);
((EvalRelationalExpressionContext)_localctx).g = match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2127);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) {
case 1:
{
{
setState(2121);
match(LPAREN);
setState(2123);
_errHandler.sync(this);
_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(2122);
expressionList();
}
}
setState(2125);
match(RPAREN);
}
}
break;
case 2:
{
setState(2126);
subSelectGroupExpression();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2135);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case 2:
{
setState(2137);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_EXPR) {
{
setState(2136);
((EvalRelationalExpressionContext)_localctx).n = match(NOT_EXPR);
}
}
setState(2172);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) {
case 1:
{
{
setState(2139);
((EvalRelationalExpressionContext)_localctx).in = match(IN_SET);
setState(2142);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
{
setState(2140);
((EvalRelationalExpressionContext)_localctx).l = match(LPAREN);
}
break;
case LBRACK:
{
setState(2141);
((EvalRelationalExpressionContext)_localctx).l = match(LBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2144);
expression();
setState(2154);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
{
{
setState(2145);
((EvalRelationalExpressionContext)_localctx).col = match(COLON);
{
setState(2146);
expression();
}
}
}
break;
case RPAREN:
case RBRACK:
case COMMA:
{
{
setState(2151);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2147);
match(COMMA);
setState(2148);
expression();
}
}
setState(2153);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2158);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RPAREN:
{
setState(2156);
((EvalRelationalExpressionContext)_localctx).r = match(RPAREN);
}
break;
case RBRACK:
{
setState(2157);
((EvalRelationalExpressionContext)_localctx).r = match(RBRACK);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
case 2:
{
setState(2160);
((EvalRelationalExpressionContext)_localctx).inset = match(IN_SET);
setState(2161);
inSubSelectQuery();
}
break;
case 3:
{
setState(2162);
((EvalRelationalExpressionContext)_localctx).between = match(BETWEEN);
setState(2163);
betweenList();
}
break;
case 4:
{
setState(2164);
((EvalRelationalExpressionContext)_localctx).like = match(LIKE);
setState(2165);
concatenationExpr();
setState(2168);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,284,_ctx) ) {
case 1:
{
setState(2166);
match(ESCAPE);
setState(2167);
stringconstant();
}
break;
}
}
break;
case 5:
{
setState(2170);
((EvalRelationalExpressionContext)_localctx).regex = match(REGEXP);
setState(2171);
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, 308, RULE_inSubSelectQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(2176);
subQueryExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConcatenationExprContext extends ParserRuleContext {
public Token c;
public List additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public List LOR() { return getTokens(EsperEPL2GrammarParser.LOR); }
public TerminalNode LOR(int i) {
return getToken(EsperEPL2GrammarParser.LOR, i);
}
public ConcatenationExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_concatenationExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterConcatenationExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitConcatenationExpr(this);
}
}
public final ConcatenationExprContext concatenationExpr() throws RecognitionException {
ConcatenationExprContext _localctx = new ConcatenationExprContext(_ctx, getState());
enterRule(_localctx, 310, RULE_concatenationExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2178);
additiveExpression();
setState(2188);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOR) {
{
setState(2179);
((ConcatenationExprContext)_localctx).c = match(LOR);
setState(2180);
additiveExpression();
setState(2185);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOR) {
{
{
setState(2181);
match(LOR);
setState(2182);
additiveExpression();
}
}
setState(2187);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public List multiplyExpression() {
return getRuleContexts(MultiplyExpressionContext.class);
}
public MultiplyExpressionContext multiplyExpression(int i) {
return getRuleContext(MultiplyExpressionContext.class,i);
}
public List PLUS() { return getTokens(EsperEPL2GrammarParser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(EsperEPL2GrammarParser.PLUS, i);
}
public List MINUS() { return getTokens(EsperEPL2GrammarParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(EsperEPL2GrammarParser.MINUS, i);
}
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitAdditiveExpression(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState());
enterRule(_localctx, 312, RULE_additiveExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2190);
multiplyExpression();
setState(2195);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,289,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2191);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2192);
multiplyExpression();
}
}
}
setState(2197);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,289,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiplyExpressionContext extends ParserRuleContext {
public List unaryExpression() {
return getRuleContexts(UnaryExpressionContext.class);
}
public UnaryExpressionContext unaryExpression(int i) {
return getRuleContext(UnaryExpressionContext.class,i);
}
public List STAR() { return getTokens(EsperEPL2GrammarParser.STAR); }
public TerminalNode STAR(int i) {
return getToken(EsperEPL2GrammarParser.STAR, i);
}
public List DIV() { return getTokens(EsperEPL2GrammarParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(EsperEPL2GrammarParser.DIV, i);
}
public List MOD() { return getTokens(EsperEPL2GrammarParser.MOD); }
public TerminalNode MOD(int i) {
return getToken(EsperEPL2GrammarParser.MOD, i);
}
public MultiplyExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplyExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMultiplyExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMultiplyExpression(this);
}
}
public final MultiplyExpressionContext multiplyExpression() throws RecognitionException {
MultiplyExpressionContext _localctx = new MultiplyExpressionContext(_ctx, getState());
enterRule(_localctx, 314, RULE_multiplyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2198);
unaryExpression();
setState(2203);
_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(2199);
_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 {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2200);
unaryExpression();
}
}
setState(2205);
_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 UnaryMinusContext unaryMinus() {
return getRuleContext(UnaryMinusContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public SubstitutionCanChainContext substitutionCanChain() {
return getRuleContext(SubstitutionCanChainContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public 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 newAssign() {
return getRuleContexts(NewAssignContext.class);
}
public NewAssignContext newAssign(int i) {
return getRuleContext(NewAssignContext.class,i);
}
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public 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, 316, RULE_unaryExpression);
int _la;
try {
setState(2264);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2206);
unaryMinus();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2207);
constant();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2208);
substitutionCanChain();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2209);
((UnaryExpressionContext)_localctx).inner = match(LPAREN);
setState(2210);
expression();
setState(2211);
match(RPAREN);
setState(2213);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2212);
chainedFunction();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2215);
builtinFunc();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2216);
eventPropertyOrLibFunction();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2217);
arrayExpression();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2218);
rowSubSelectExpression();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2219);
existsSubSelectExpression();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2220);
match(NEWKW);
setState(2221);
match(LCURLY);
setState(2222);
newAssign();
setState(2227);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2223);
match(COMMA);
setState(2224);
newAssign();
}
}
setState(2229);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2230);
match(RCURLY);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2232);
match(NEWKW);
setState(2233);
classIdentifier();
setState(2234);
match(LPAREN);
setState(2243);
_errHandler.sync(this);
_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(2235);
expression();
setState(2240);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2236);
match(COMMA);
setState(2237);
expression();
}
}
setState(2242);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2245);
match(RPAREN);
setState(2247);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2246);
chainedFunction();
}
}
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2249);
((UnaryExpressionContext)_localctx).b = match(IDENT);
setState(2250);
match(LBRACK);
setState(2251);
expression();
setState(2256);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2252);
match(COMMA);
setState(2253);
expression();
}
}
setState(2258);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2259);
match(RBRACK);
setState(2261);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2260);
chainedFunction();
}
}
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2263);
jsonobject();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryMinusContext extends ParserRuleContext {
public TerminalNode MINUS() { return getToken(EsperEPL2GrammarParser.MINUS, 0); }
public EventPropertyContext eventProperty() {
return getRuleContext(EventPropertyContext.class,0);
}
public UnaryMinusContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryMinus; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterUnaryMinus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitUnaryMinus(this);
}
}
public final UnaryMinusContext unaryMinus() throws RecognitionException {
UnaryMinusContext _localctx = new UnaryMinusContext(_ctx, getState());
enterRule(_localctx, 318, RULE_unaryMinus);
try {
enterOuterAlt(_localctx, 1);
{
setState(2266);
match(MINUS);
setState(2267);
eventProperty();
}
}
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, 320, RULE_substitutionCanChain);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2269);
substitution();
setState(2271);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2270);
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 libFunctionNoClass() {
return getRuleContexts(LibFunctionNoClassContext.class);
}
public LibFunctionNoClassContext libFunctionNoClass(int i) {
return getRuleContext(LibFunctionNoClassContext.class,i);
}
public List 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, 322, RULE_chainedFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2273);
((ChainedFunctionContext)_localctx).d = match(DOT);
setState(2274);
libFunctionNoClass();
setState(2279);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2275);
((ChainedFunctionContext)_localctx).d = match(DOT);
setState(2276);
libFunctionNoClass();
}
}
setState(2281);
_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, 324, RULE_newAssign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2282);
eventProperty();
setState(2285);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(2283);
match(EQUALS);
setState(2284);
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, 326, RULE_rowSubSelectExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2287);
subQueryExpr();
setState(2289);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2288);
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, 328, RULE_subSelectGroupExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2291);
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, 330, RULE_existsSubSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2293);
match(EXISTS);
setState(2294);
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, 332, RULE_subQueryExpr);
paraphrases.push("subquery");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2296);
match(LPAREN);
setState(2297);
match(SELECT);
setState(2299);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(2298);
match(DISTINCT);
}
}
setState(2301);
selectionList();
setState(2302);
match(FROM);
setState(2303);
subSelectFilterExpr();
setState(2306);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2304);
match(WHERE);
setState(2305);
whereClause();
}
}
setState(2311);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(2308);
match(GROUP);
setState(2309);
match(BY);
setState(2310);
groupByListExpr();
}
}
setState(2315);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(2313);
match(HAVING);
setState(2314);
havingClause();
}
}
setState(2317);
match(RPAREN);
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubSelectFilterExprContext extends ParserRuleContext {
public Token ru;
public Token ri;
public EventFilterExpressionContext eventFilterExpression() {
return getRuleContext(EventFilterExpressionContext.class,0);
}
public ViewExpressionsContext viewExpressions() {
return getRuleContext(ViewExpressionsContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public IdentOrTickedContext identOrTicked() {
return getRuleContext(IdentOrTickedContext.class,0);
}
public TerminalNode RETAINUNION() { return getToken(EsperEPL2GrammarParser.RETAINUNION, 0); }
public TerminalNode RETAININTERSECTION() { return getToken(EsperEPL2GrammarParser.RETAININTERSECTION, 0); }
public SubSelectFilterExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subSelectFilterExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubSelectFilterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubSelectFilterExpr(this);
}
}
public final SubSelectFilterExprContext subSelectFilterExpr() throws RecognitionException {
SubSelectFilterExprContext _localctx = new SubSelectFilterExprContext(_ctx, getState());
enterRule(_localctx, 334, RULE_subSelectFilterExpr);
paraphrases.push("subquery filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2319);
eventFilterExpression();
setState(2321);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT || _la==HASHCHAR) {
{
setState(2320);
viewExpressions();
}
}
setState(2326);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
{
setState(2323);
match(AS);
setState(2324);
identOrTicked();
}
break;
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(2325);
identOrTicked();
}
break;
case WHERE:
case GROUP:
case HAVING:
case RETAINUNION:
case RETAININTERSECTION:
case RPAREN:
break;
default:
break;
}
setState(2330);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RETAINUNION:
{
setState(2328);
((SubSelectFilterExprContext)_localctx).ru = match(RETAINUNION);
}
break;
case RETAININTERSECTION:
{
setState(2329);
((SubSelectFilterExprContext)_localctx).ri = match(RETAININTERSECTION);
}
break;
case WHERE:
case GROUP:
case HAVING:
case RPAREN:
break;
default:
break;
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayExpressionContext extends ParserRuleContext {
public TerminalNode LCURLY() { return getToken(EsperEPL2GrammarParser.LCURLY, 0); }
public TerminalNode RCURLY() { return getToken(EsperEPL2GrammarParser.RCURLY, 0); }
public List 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 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, 336, RULE_arrayExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2332);
match(LCURLY);
setState(2341);
_errHandler.sync(this);
_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(2333);
expression();
setState(2338);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2334);
match(COMMA);
setState(2335);
expression();
}
}
setState(2340);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(2343);
match(RCURLY);
setState(2345);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2344);
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 ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public 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 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 expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_coalesceContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_coalesce(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_coalesce(this);
}
}
public static class Builtin_prevContext extends BuiltinFuncContext {
public TerminalNode PREVIOUS() { return getToken(EsperEPL2GrammarParser.PREVIOUS, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public 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 COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public List classIdentifier() {
return getRuleContexts(ClassIdentifierContext.class);
}
public ClassIdentifierContext classIdentifier(int i) {
return getRuleContext(ClassIdentifierContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public Builtin_instanceofContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_instanceof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_instanceof(this);
}
}
public static class Builtin_avgContext extends BuiltinFuncContext {
public TerminalNode AVG() { return getToken(EsperEPL2GrammarParser.AVG, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_avgContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_avg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_avg(this);
}
}
public static class Builtin_avedevContext extends BuiltinFuncContext {
public TerminalNode AVEDEV() { return getToken(EsperEPL2GrammarParser.AVEDEV, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public ExpressionListWithNamedContext expressionListWithNamed() {
return getRuleContext(ExpressionListWithNamedContext.class,0);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public Builtin_avedevContext(BuiltinFuncContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBuiltin_avedev(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBuiltin_avedev(this);
}
}
public final BuiltinFuncContext builtinFunc() throws RecognitionException {
BuiltinFuncContext _localctx = new BuiltinFuncContext(_ctx, getState());
enterRule(_localctx, 338, RULE_builtinFunc);
int _la;
try {
setState(2510);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SUM:
_localctx = new Builtin_sumContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(2347);
match(SUM);
setState(2348);
match(LPAREN);
setState(2350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2349);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2352);
expressionListWithNamed();
setState(2353);
match(RPAREN);
}
break;
case AVG:
_localctx = new Builtin_avgContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(2355);
match(AVG);
setState(2356);
match(LPAREN);
setState(2358);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2357);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2360);
expressionListWithNamed();
setState(2361);
match(RPAREN);
}
break;
case COUNT:
_localctx = new Builtin_cntContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(2363);
match(COUNT);
setState(2364);
match(LPAREN);
setState(2367);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
{
setState(2365);
((Builtin_cntContext)_localctx).a = match(ALL);
}
break;
case DISTINCT:
{
setState(2366);
((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:
break;
}
setState(2369);
expressionListWithNamed();
setState(2370);
match(RPAREN);
}
break;
case MEDIAN:
_localctx = new Builtin_medianContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(2372);
match(MEDIAN);
setState(2373);
match(LPAREN);
setState(2375);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2374);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2377);
expressionListWithNamed();
setState(2378);
match(RPAREN);
}
break;
case STDDEV:
_localctx = new Builtin_stddevContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(2380);
match(STDDEV);
setState(2381);
match(LPAREN);
setState(2383);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2382);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2385);
expressionListWithNamed();
setState(2386);
match(RPAREN);
}
break;
case AVEDEV:
_localctx = new Builtin_avedevContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(2388);
match(AVEDEV);
setState(2389);
match(LPAREN);
setState(2391);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2390);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2393);
expressionListWithNamed();
setState(2394);
match(RPAREN);
}
break;
case WINDOW:
case FIRST:
case LAST:
_localctx = new Builtin_firstlastwindowContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(2396);
firstLastWindowAggregation();
}
break;
case COALESCE:
_localctx = new Builtin_coalesceContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(2397);
match(COALESCE);
setState(2398);
match(LPAREN);
setState(2399);
expression();
setState(2400);
match(COMMA);
setState(2401);
expression();
setState(2406);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2402);
match(COMMA);
setState(2403);
expression();
}
}
setState(2408);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2409);
match(RPAREN);
}
break;
case PREVIOUS:
_localctx = new Builtin_prevContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(2411);
match(PREVIOUS);
setState(2412);
match(LPAREN);
setState(2413);
expression();
setState(2416);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2414);
match(COMMA);
setState(2415);
expression();
}
}
setState(2418);
match(RPAREN);
setState(2420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2419);
chainedFunction();
}
}
}
break;
case PREVIOUSTAIL:
_localctx = new Builtin_prevtailContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(2422);
match(PREVIOUSTAIL);
setState(2423);
match(LPAREN);
setState(2424);
expression();
setState(2427);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2425);
match(COMMA);
setState(2426);
expression();
}
}
setState(2429);
match(RPAREN);
setState(2431);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2430);
chainedFunction();
}
}
}
break;
case PREVIOUSCOUNT:
_localctx = new Builtin_prevcountContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(2433);
match(PREVIOUSCOUNT);
setState(2434);
match(LPAREN);
setState(2435);
expression();
setState(2436);
match(RPAREN);
}
break;
case PREVIOUSWINDOW:
_localctx = new Builtin_prevwindowContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(2438);
match(PREVIOUSWINDOW);
setState(2439);
match(LPAREN);
setState(2440);
expression();
setState(2441);
match(RPAREN);
setState(2443);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2442);
chainedFunction();
}
}
}
break;
case PRIOR:
_localctx = new Builtin_priorContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(2445);
match(PRIOR);
setState(2446);
match(LPAREN);
setState(2447);
expression();
setState(2448);
match(COMMA);
setState(2449);
eventProperty();
setState(2450);
match(RPAREN);
}
break;
case GROUPING:
_localctx = new Builtin_groupingContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(2452);
match(GROUPING);
setState(2453);
match(LPAREN);
setState(2454);
expression();
setState(2455);
match(RPAREN);
}
break;
case GROUPING_ID:
_localctx = new Builtin_groupingidContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(2457);
match(GROUPING_ID);
setState(2458);
match(LPAREN);
setState(2459);
expressionList();
setState(2460);
match(RPAREN);
}
break;
case INSTANCEOF:
_localctx = new Builtin_instanceofContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(2462);
match(INSTANCEOF);
setState(2463);
match(LPAREN);
setState(2464);
expression();
setState(2465);
match(COMMA);
setState(2466);
classIdentifier();
setState(2471);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2467);
match(COMMA);
setState(2468);
classIdentifier();
}
}
setState(2473);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2474);
match(RPAREN);
}
break;
case TYPEOF:
_localctx = new Builtin_typeofContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(2476);
match(TYPEOF);
setState(2477);
match(LPAREN);
setState(2478);
expression();
setState(2479);
match(RPAREN);
}
break;
case CAST:
_localctx = new Builtin_castContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(2481);
match(CAST);
setState(2482);
match(LPAREN);
setState(2483);
expression();
setState(2484);
_la = _input.LA(1);
if ( !(_la==AS || _la==COMMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2485);
classIdentifierWithDimensions();
setState(2488);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(2486);
match(COMMA);
setState(2487);
expressionNamedParameter();
}
}
setState(2490);
match(RPAREN);
setState(2492);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2491);
chainedFunction();
}
}
}
break;
case EXISTS:
_localctx = new Builtin_existsContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(2494);
match(EXISTS);
setState(2495);
match(LPAREN);
setState(2496);
eventProperty();
setState(2497);
match(RPAREN);
}
break;
case CURRENT_TIMESTAMP:
_localctx = new Builtin_currtsContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(2499);
match(CURRENT_TIMESTAMP);
setState(2502);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,328,_ctx) ) {
case 1:
{
setState(2500);
match(LPAREN);
setState(2501);
match(RPAREN);
}
break;
}
setState(2505);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2504);
chainedFunction();
}
}
}
break;
case ISTREAM:
_localctx = new Builtin_istreamContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(2507);
match(ISTREAM);
setState(2508);
match(LPAREN);
setState(2509);
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, 340, RULE_firstLastWindowAggregation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2515);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FIRST:
{
setState(2512);
((FirstLastWindowAggregationContext)_localctx).q = match(FIRST);
}
break;
case LAST:
{
setState(2513);
((FirstLastWindowAggregationContext)_localctx).q = match(LAST);
}
break;
case WINDOW:
{
setState(2514);
((FirstLastWindowAggregationContext)_localctx).q = match(WINDOW);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2517);
match(LPAREN);
setState(2519);
_errHandler.sync(this);
_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(2518);
expressionListWithNamed();
}
}
setState(2521);
match(RPAREN);
setState(2523);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(2522);
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, 342, RULE_eventPropertyOrLibFunction);
try {
setState(2527);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,334,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2525);
eventProperty();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2526);
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 DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public List 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, 344, RULE_libFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2529);
libFunctionWithClass();
setState(2534);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2530);
match(DOT);
setState(2531);
libFunctionNoClass();
}
}
setState(2536);
_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, 346, RULE_libFunctionWithClass);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2542);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,336,_ctx) ) {
case 1:
{
{
setState(2537);
classIdentifier();
setState(2538);
match(DOT);
setState(2539);
funcIdentInner();
}
}
break;
case 2:
{
setState(2541);
funcIdentTop();
}
break;
}
setState(2549);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,338,_ctx) ) {
case 1:
{
setState(2544);
((LibFunctionWithClassContext)_localctx).l = match(LPAREN);
setState(2546);
_errHandler.sync(this);
_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(2545);
libFunctionArgs();
}
}
setState(2548);
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, 348, RULE_libFunctionNoClass);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2551);
funcIdentChained();
setState(2557);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,340,_ctx) ) {
case 1:
{
setState(2552);
((LibFunctionNoClassContext)_localctx).l = match(LPAREN);
setState(2554);
_errHandler.sync(this);
_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(2553);
libFunctionArgs();
}
}
setState(2556);
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, 350, RULE_funcIdentTop);
try {
setState(2562);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2559);
escapableIdent();
}
break;
case MAX:
enterOuterAlt(_localctx, 2);
{
setState(2560);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 3);
{
setState(2561);
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, 352, RULE_funcIdentInner);
try {
setState(2568);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2564);
escapableIdent();
}
break;
case LAST:
enterOuterAlt(_localctx, 2);
{
setState(2565);
match(LAST);
}
break;
case FIRST:
enterOuterAlt(_localctx, 3);
{
setState(2566);
match(FIRST);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 4);
{
setState(2567);
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, 354, RULE_funcIdentChained);
try {
setState(2580);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TICKED_STRING_LITERAL:
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(2570);
escapableIdent();
}
break;
case LAST:
enterOuterAlt(_localctx, 2);
{
setState(2571);
match(LAST);
}
break;
case FIRST:
enterOuterAlt(_localctx, 3);
{
setState(2572);
match(FIRST);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 4);
{
setState(2573);
match(WINDOW);
}
break;
case MAX:
enterOuterAlt(_localctx, 5);
{
setState(2574);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 6);
{
setState(2575);
match(MIN);
}
break;
case WHERE:
enterOuterAlt(_localctx, 7);
{
setState(2576);
match(WHERE);
}
break;
case SET:
enterOuterAlt(_localctx, 8);
{
setState(2577);
match(SET);
}
break;
case AFTER:
enterOuterAlt(_localctx, 9);
{
setState(2578);
match(AFTER);
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 10);
{
setState(2579);
match(BETWEEN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LibFunctionArgsContext extends ParserRuleContext {
public List libFunctionArgItem() {
return getRuleContexts(LibFunctionArgItemContext.class);
}
public LibFunctionArgItemContext libFunctionArgItem(int i) {
return getRuleContext(LibFunctionArgItemContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public TerminalNode ALL() { return getToken(EsperEPL2GrammarParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(EsperEPL2GrammarParser.DISTINCT, 0); }
public LibFunctionArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libFunctionArgs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLibFunctionArgs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLibFunctionArgs(this);
}
}
public final LibFunctionArgsContext libFunctionArgs() throws RecognitionException {
LibFunctionArgsContext _localctx = new LibFunctionArgsContext(_ctx, getState());
enterRule(_localctx, 356, RULE_libFunctionArgs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2583);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2582);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==ALL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(2585);
libFunctionArgItem();
setState(2590);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2586);
match(COMMA);
setState(2587);
libFunctionArgItem();
}
}
setState(2592);
_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, 358, RULE_libFunctionArgItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2594);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,346,_ctx) ) {
case 1:
{
setState(2593);
expressionLambdaDecl();
}
break;
}
setState(2596);
expressionWithNamed();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BetweenListContext extends ParserRuleContext {
public List concatenationExpr() {
return getRuleContexts(ConcatenationExprContext.class);
}
public ConcatenationExprContext concatenationExpr(int i) {
return getRuleContext(ConcatenationExprContext.class,i);
}
public TerminalNode AND_EXPR() { return getToken(EsperEPL2GrammarParser.AND_EXPR, 0); }
public BetweenListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_betweenList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterBetweenList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitBetweenList(this);
}
}
public final BetweenListContext betweenList() throws RecognitionException {
BetweenListContext _localctx = new BetweenListContext(_ctx, getState());
enterRule(_localctx, 360, RULE_betweenList);
try {
enterOuterAlt(_localctx, 1);
{
setState(2598);
concatenationExpr();
setState(2599);
match(AND_EXPR);
setState(2600);
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, 362, RULE_patternExpression);
paraphrases.push("pattern expression");
try {
enterOuterAlt(_localctx, 1);
{
setState(2602);
followedByExpression();
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FollowedByExpressionContext extends ParserRuleContext {
public OrExpressionContext orExpression() {
return getRuleContext(OrExpressionContext.class,0);
}
public List followedByRepeat() {
return getRuleContexts(FollowedByRepeatContext.class);
}
public FollowedByRepeatContext followedByRepeat(int i) {
return getRuleContext(FollowedByRepeatContext.class,i);
}
public FollowedByExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_followedByExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterFollowedByExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitFollowedByExpression(this);
}
}
public final FollowedByExpressionContext followedByExpression() throws RecognitionException {
FollowedByExpressionContext _localctx = new FollowedByExpressionContext(_ctx, getState());
enterRule(_localctx, 364, RULE_followedByExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2604);
orExpression();
setState(2608);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOLLOWMAX_BEGIN || _la==FOLLOWED_BY) {
{
{
setState(2605);
followedByRepeat();
}
}
setState(2610);
_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, 366, RULE_followedByRepeat);
try {
enterOuterAlt(_localctx, 1);
{
setState(2616);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOLLOWED_BY:
{
setState(2611);
((FollowedByRepeatContext)_localctx).f = match(FOLLOWED_BY);
}
break;
case FOLLOWMAX_BEGIN:
{
{
setState(2612);
((FollowedByRepeatContext)_localctx).g = match(FOLLOWMAX_BEGIN);
setState(2613);
expression();
setState(2614);
match(FOLLOWMAX_END);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2618);
orExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrExpressionContext extends ParserRuleContext {
public Token o;
public List andExpression() {
return getRuleContexts(AndExpressionContext.class);
}
public AndExpressionContext andExpression(int i) {
return getRuleContext(AndExpressionContext.class,i);
}
public List OR_EXPR() { return getTokens(EsperEPL2GrammarParser.OR_EXPR); }
public TerminalNode OR_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.OR_EXPR, i);
}
public OrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitOrExpression(this);
}
}
public final OrExpressionContext orExpression() throws RecognitionException {
OrExpressionContext _localctx = new OrExpressionContext(_ctx, getState());
enterRule(_localctx, 368, RULE_orExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2620);
andExpression();
setState(2625);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_EXPR) {
{
{
setState(2621);
((OrExpressionContext)_localctx).o = match(OR_EXPR);
setState(2622);
andExpression();
}
}
setState(2627);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndExpressionContext extends ParserRuleContext {
public Token a;
public List matchUntilExpression() {
return getRuleContexts(MatchUntilExpressionContext.class);
}
public MatchUntilExpressionContext matchUntilExpression(int i) {
return getRuleContext(MatchUntilExpressionContext.class,i);
}
public List AND_EXPR() { return getTokens(EsperEPL2GrammarParser.AND_EXPR); }
public TerminalNode AND_EXPR(int i) {
return getToken(EsperEPL2GrammarParser.AND_EXPR, i);
}
public AndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitAndExpression(this);
}
}
public final AndExpressionContext andExpression() throws RecognitionException {
AndExpressionContext _localctx = new AndExpressionContext(_ctx, getState());
enterRule(_localctx, 370, RULE_andExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2628);
matchUntilExpression();
setState(2633);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_EXPR) {
{
{
setState(2629);
((AndExpressionContext)_localctx).a = match(AND_EXPR);
setState(2630);
matchUntilExpression();
}
}
setState(2635);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchUntilExpressionContext extends ParserRuleContext {
public MatchUntilRangeContext r;
public QualifyExpressionContext until;
public List qualifyExpression() {
return getRuleContexts(QualifyExpressionContext.class);
}
public QualifyExpressionContext qualifyExpression(int i) {
return getRuleContext(QualifyExpressionContext.class,i);
}
public TerminalNode UNTIL() { return getToken(EsperEPL2GrammarParser.UNTIL, 0); }
public MatchUntilRangeContext matchUntilRange() {
return getRuleContext(MatchUntilRangeContext.class,0);
}
public MatchUntilExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchUntilExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchUntilExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchUntilExpression(this);
}
}
public final MatchUntilExpressionContext matchUntilExpression() throws RecognitionException {
MatchUntilExpressionContext _localctx = new MatchUntilExpressionContext(_ctx, getState());
enterRule(_localctx, 372, RULE_matchUntilExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2637);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2636);
((MatchUntilExpressionContext)_localctx).r = matchUntilRange();
}
}
setState(2639);
qualifyExpression();
setState(2642);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNTIL) {
{
setState(2640);
match(UNTIL);
setState(2641);
((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, 374, RULE_qualifyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2653);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT_EXPR) | (1L << EVERY_EXPR) | (1L << EVERY_DISTINCT_EXPR))) != 0)) {
{
setState(2648);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVERY_EXPR:
{
setState(2644);
((QualifyExpressionContext)_localctx).e = match(EVERY_EXPR);
}
break;
case NOT_EXPR:
{
setState(2645);
((QualifyExpressionContext)_localctx).n = match(NOT_EXPR);
}
break;
case EVERY_DISTINCT_EXPR:
{
setState(2646);
((QualifyExpressionContext)_localctx).d = match(EVERY_DISTINCT_EXPR);
setState(2647);
distinctExpressionList();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2651);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2650);
matchUntilRange();
}
}
}
}
setState(2655);
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, 376, RULE_guardPostFix);
try {
enterOuterAlt(_localctx, 1);
{
setState(2662);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EVENTS:
case TICKED_STRING_LITERAL:
case IDENT:
{
setState(2657);
atomicExpression();
}
break;
case LPAREN:
{
setState(2658);
((GuardPostFixContext)_localctx).l = match(LPAREN);
setState(2659);
patternExpression();
setState(2660);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2668);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WHERE:
{
{
setState(2664);
((GuardPostFixContext)_localctx).wh = match(WHERE);
setState(2665);
guardWhereExpression();
}
}
break;
case WHILE:
{
{
setState(2666);
((GuardPostFixContext)_localctx).wi = match(WHILE);
setState(2667);
guardWhileExpression();
}
}
break;
case OR_EXPR:
case AND_EXPR:
case UNTIL:
case FOLLOWMAX_BEGIN:
case FOLLOWED_BY:
case RPAREN:
case RBRACK:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DistinctExpressionListContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public List distinctExpressionAtom() {
return getRuleContexts(DistinctExpressionAtomContext.class);
}
public DistinctExpressionAtomContext distinctExpressionAtom(int i) {
return getRuleContext(DistinctExpressionAtomContext.class,i);
}
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public DistinctExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_distinctExpressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDistinctExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDistinctExpressionList(this);
}
}
public final DistinctExpressionListContext distinctExpressionList() throws RecognitionException {
DistinctExpressionListContext _localctx = new DistinctExpressionListContext(_ctx, getState());
enterRule(_localctx, 378, RULE_distinctExpressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2670);
match(LPAREN);
setState(2671);
distinctExpressionAtom();
setState(2676);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2672);
match(COMMA);
setState(2673);
distinctExpressionAtom();
}
}
setState(2678);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2679);
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, 380, RULE_distinctExpressionAtom);
try {
enterOuterAlt(_localctx, 1);
{
setState(2681);
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, 382, RULE_atomicExpression);
try {
setState(2685);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,359,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2683);
observerExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2684);
patternFilterExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObserverExpressionContext extends ParserRuleContext {
public Token ns;
public Token nm;
public Token a;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AT() { return getToken(EsperEPL2GrammarParser.AT, 0); }
public ExpressionListWithNamedWithTimeContext expressionListWithNamedWithTime() {
return getRuleContext(ExpressionListWithNamedWithTimeContext.class,0);
}
public ObserverExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_observerExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterObserverExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitObserverExpression(this);
}
}
public final ObserverExpressionContext observerExpression() throws RecognitionException {
ObserverExpressionContext _localctx = new ObserverExpressionContext(_ctx, getState());
enterRule(_localctx, 384, RULE_observerExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2687);
((ObserverExpressionContext)_localctx).ns = match(IDENT);
setState(2688);
match(COLON);
setState(2691);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
{
setState(2689);
((ObserverExpressionContext)_localctx).nm = match(IDENT);
}
break;
case AT:
{
setState(2690);
((ObserverExpressionContext)_localctx).a = match(AT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2693);
match(LPAREN);
setState(2695);
_errHandler.sync(this);
_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(2694);
expressionListWithNamedWithTime();
}
}
setState(2697);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GuardWhereExpressionContext extends ParserRuleContext {
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public ExpressionWithTimeListContext expressionWithTimeList() {
return getRuleContext(ExpressionWithTimeListContext.class,0);
}
public GuardWhereExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_guardWhereExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterGuardWhereExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitGuardWhereExpression(this);
}
}
public final GuardWhereExpressionContext guardWhereExpression() throws RecognitionException {
GuardWhereExpressionContext _localctx = new GuardWhereExpressionContext(_ctx, getState());
enterRule(_localctx, 386, RULE_guardWhereExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2699);
match(IDENT);
setState(2700);
match(COLON);
setState(2701);
match(IDENT);
setState(2702);
match(LPAREN);
setState(2704);
_errHandler.sync(this);
_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(2703);
expressionWithTimeList();
}
}
setState(2706);
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, 388, RULE_guardWhileExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2708);
match(LPAREN);
setState(2709);
expression();
setState(2710);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchUntilRangeContext extends ParserRuleContext {
public ExpressionContext low;
public Token c1;
public ExpressionContext high;
public Token c2;
public ExpressionContext upper;
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public MatchUntilRangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchUntilRange; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMatchUntilRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMatchUntilRange(this);
}
}
public final MatchUntilRangeContext matchUntilRange() throws RecognitionException {
MatchUntilRangeContext _localctx = new MatchUntilRangeContext(_ctx, getState());
enterRule(_localctx, 390, RULE_matchUntilRange);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2712);
match(LBRACK);
setState(2722);
_errHandler.sync(this);
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(2713);
((MatchUntilRangeContext)_localctx).low = expression();
setState(2718);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(2714);
((MatchUntilRangeContext)_localctx).c1 = match(COLON);
setState(2716);
_errHandler.sync(this);
_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(2715);
((MatchUntilRangeContext)_localctx).high = expression();
}
}
}
}
}
break;
case COLON:
{
setState(2720);
((MatchUntilRangeContext)_localctx).c2 = match(COLON);
setState(2721);
((MatchUntilRangeContext)_localctx).upper = expression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2724);
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, 392, RULE_eventFilterExpression);
paraphrases.push("filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2728);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,366,_ctx) ) {
case 1:
{
setState(2726);
((EventFilterExpressionContext)_localctx).i = match(IDENT);
setState(2727);
match(EQUALS);
}
break;
}
setState(2730);
classIdentifier();
setState(2736);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2731);
match(LPAREN);
setState(2733);
_errHandler.sync(this);
_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(2732);
expressionList();
}
}
setState(2735);
match(RPAREN);
}
}
setState(2739);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2738);
propertyExpression();
}
}
}
_ctx.stop = _input.LT(-1);
paraphrases.pop();
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyExpressionContext extends ParserRuleContext {
public List propertyExpressionAtomic() {
return getRuleContexts(PropertyExpressionAtomicContext.class);
}
public PropertyExpressionAtomicContext propertyExpressionAtomic(int i) {
return getRuleContext(PropertyExpressionAtomicContext.class,i);
}
public PropertyExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyExpression(this);
}
}
public final PropertyExpressionContext propertyExpression() throws RecognitionException {
PropertyExpressionContext _localctx = new PropertyExpressionContext(_ctx, getState());
enterRule(_localctx, 394, RULE_propertyExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2741);
propertyExpressionAtomic();
setState(2745);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2742);
propertyExpressionAtomic();
}
}
setState(2747);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyExpressionAtomicContext extends ParserRuleContext {
public Token n;
public ExpressionContext where;
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public PropertyExpressionSelectContext propertyExpressionSelect() {
return getRuleContext(PropertyExpressionSelectContext.class,0);
}
public TypeExpressionAnnotationContext typeExpressionAnnotation() {
return getRuleContext(TypeExpressionAnnotationContext.class,0);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public TerminalNode WHERE() { return getToken(EsperEPL2GrammarParser.WHERE, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public PropertyExpressionAtomicContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyExpressionAtomic; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyExpressionAtomic(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyExpressionAtomic(this);
}
}
public final PropertyExpressionAtomicContext propertyExpressionAtomic() throws RecognitionException {
PropertyExpressionAtomicContext _localctx = new PropertyExpressionAtomicContext(_ctx, getState());
enterRule(_localctx, 396, RULE_propertyExpressionAtomic);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2748);
match(LBRACK);
setState(2750);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(2749);
propertyExpressionSelect();
}
}
setState(2752);
expression();
setState(2754);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(2753);
typeExpressionAnnotation();
}
}
setState(2758);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2756);
match(AS);
setState(2757);
((PropertyExpressionAtomicContext)_localctx).n = match(IDENT);
}
}
setState(2762);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2760);
match(WHERE);
setState(2761);
((PropertyExpressionAtomicContext)_localctx).where = expression();
}
}
setState(2764);
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, 398, RULE_propertyExpressionSelect);
try {
enterOuterAlt(_localctx, 1);
{
setState(2766);
match(SELECT);
setState(2767);
propertySelectionList();
setState(2768);
match(FROM);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertySelectionListContext extends ParserRuleContext {
public List propertySelectionListElement() {
return getRuleContexts(PropertySelectionListElementContext.class);
}
public PropertySelectionListElementContext propertySelectionListElement(int i) {
return getRuleContext(PropertySelectionListElementContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public PropertySelectionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertySelectionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertySelectionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertySelectionList(this);
}
}
public final PropertySelectionListContext propertySelectionList() throws RecognitionException {
PropertySelectionListContext _localctx = new PropertySelectionListContext(_ctx, getState());
enterRule(_localctx, 400, RULE_propertySelectionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2770);
propertySelectionListElement();
setState(2775);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2771);
match(COMMA);
setState(2772);
propertySelectionListElement();
}
}
setState(2777);
_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, 402, RULE_propertySelectionListElement);
int _la;
try {
setState(2785);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,377,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2778);
((PropertySelectionListElementContext)_localctx).s = match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2779);
propertyStreamSelector();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2780);
expression();
setState(2783);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2781);
match(AS);
setState(2782);
keywordAllowedIdent();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyStreamSelectorContext extends ParserRuleContext {
public Token s;
public Token i;
public TerminalNode DOT() { return getToken(EsperEPL2GrammarParser.DOT, 0); }
public TerminalNode STAR() { return getToken(EsperEPL2GrammarParser.STAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode AS() { return getToken(EsperEPL2GrammarParser.AS, 0); }
public PropertyStreamSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyStreamSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterPropertyStreamSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitPropertyStreamSelector(this);
}
}
public final PropertyStreamSelectorContext propertyStreamSelector() throws RecognitionException {
PropertyStreamSelectorContext _localctx = new PropertyStreamSelectorContext(_ctx, getState());
enterRule(_localctx, 404, RULE_propertyStreamSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2787);
((PropertyStreamSelectorContext)_localctx).s = match(IDENT);
setState(2788);
match(DOT);
setState(2789);
match(STAR);
setState(2792);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2790);
match(AS);
setState(2791);
((PropertyStreamSelectorContext)_localctx).i = match(IDENT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeExpressionAnnotationContext extends ParserRuleContext {
public Token n;
public Token v;
public TerminalNode ATCHAR() { return getToken(EsperEPL2GrammarParser.ATCHAR, 0); }
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public TerminalNode LPAREN() { return getToken(EsperEPL2GrammarParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(EsperEPL2GrammarParser.RPAREN, 0); }
public TypeExpressionAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeExpressionAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterTypeExpressionAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitTypeExpressionAnnotation(this);
}
}
public final TypeExpressionAnnotationContext typeExpressionAnnotation() throws RecognitionException {
TypeExpressionAnnotationContext _localctx = new TypeExpressionAnnotationContext(_ctx, getState());
enterRule(_localctx, 406, RULE_typeExpressionAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(2794);
match(ATCHAR);
setState(2795);
((TypeExpressionAnnotationContext)_localctx).n = match(IDENT);
{
setState(2796);
match(LPAREN);
setState(2797);
((TypeExpressionAnnotationContext)_localctx).v = match(IDENT);
setState(2798);
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, 408, RULE_patternFilterExpression);
paraphrases.push("filter specification");
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2802);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,379,_ctx) ) {
case 1:
{
setState(2800);
((PatternFilterExpressionContext)_localctx).i = match(IDENT);
setState(2801);
match(EQUALS);
}
break;
}
setState(2804);
classIdentifier();
setState(2810);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2805);
match(LPAREN);
setState(2807);
_errHandler.sync(this);
_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(2806);
expressionList();
}
}
setState(2809);
match(RPAREN);
}
}
setState(2813);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK) {
{
setState(2812);
propertyExpression();
}
}
setState(2816);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ATCHAR) {
{
setState(2815);
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, 410, RULE_patternFilterAnnotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2818);
match(ATCHAR);
setState(2819);
((PatternFilterAnnotationContext)_localctx).i = match(IDENT);
setState(2824);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(2820);
match(LPAREN);
setState(2821);
number();
setState(2822);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassIdentifierWithDimensionsContext extends ParserRuleContext {
public ClassIdentifierContext classIdentifier() {
return getRuleContext(ClassIdentifierContext.class,0);
}
public List dimensions() {
return getRuleContexts(DimensionsContext.class);
}
public DimensionsContext dimensions(int i) {
return getRuleContext(DimensionsContext.class,i);
}
public ClassIdentifierWithDimensionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classIdentifierWithDimensions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterClassIdentifierWithDimensions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitClassIdentifierWithDimensions(this);
}
}
public final ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() throws RecognitionException {
ClassIdentifierWithDimensionsContext _localctx = new ClassIdentifierWithDimensionsContext(_ctx, getState());
enterRule(_localctx, 412, RULE_classIdentifierWithDimensions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2826);
classIdentifier();
setState(2830);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2827);
dimensions();
}
}
setState(2832);
_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 DimensionsContext extends ParserRuleContext {
public Token p;
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public DimensionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dimensions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDimensions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDimensions(this);
}
}
public final DimensionsContext dimensions() throws RecognitionException {
DimensionsContext _localctx = new DimensionsContext(_ctx, getState());
enterRule(_localctx, 414, RULE_dimensions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2833);
match(LBRACK);
setState(2835);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENT) {
{
setState(2834);
((DimensionsContext)_localctx).p = match(IDENT);
}
}
setState(2837);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassIdentifierContext extends ParserRuleContext {
public EscapableStrContext i1;
public EscapableStrContext i2;
public List escapableStr() {
return getRuleContexts(EscapableStrContext.class);
}
public EscapableStrContext escapableStr(int i) {
return getRuleContext(EscapableStrContext.class,i);
}
public List DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public ClassIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterClassIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitClassIdentifier(this);
}
}
public final ClassIdentifierContext classIdentifier() throws RecognitionException {
ClassIdentifierContext _localctx = new ClassIdentifierContext(_ctx, getState());
enterRule(_localctx, 416, RULE_classIdentifier);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2839);
((ClassIdentifierContext)_localctx).i1 = escapableStr();
setState(2844);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,387,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2840);
match(DOT);
setState(2841);
((ClassIdentifierContext)_localctx).i2 = escapableStr();
}
}
}
setState(2846);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,387,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListWithNamedContext extends ParserRuleContext {
public List expressionWithNamed() {
return getRuleContexts(ExpressionWithNamedContext.class);
}
public ExpressionWithNamedContext expressionWithNamed(int i) {
return getRuleContext(ExpressionWithNamedContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionListWithNamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionListWithNamed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionListWithNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionListWithNamed(this);
}
}
public final ExpressionListWithNamedContext expressionListWithNamed() throws RecognitionException {
ExpressionListWithNamedContext _localctx = new ExpressionListWithNamedContext(_ctx, getState());
enterRule(_localctx, 418, RULE_expressionListWithNamed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2847);
expressionWithNamed();
setState(2852);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2848);
match(COMMA);
setState(2849);
expressionWithNamed();
}
}
setState(2854);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListWithNamedWithTimeContext extends ParserRuleContext {
public List expressionWithNamedWithTime() {
return getRuleContexts(ExpressionWithNamedWithTimeContext.class);
}
public ExpressionWithNamedWithTimeContext expressionWithNamedWithTime(int i) {
return getRuleContext(ExpressionWithNamedWithTimeContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionListWithNamedWithTimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionListWithNamedWithTime; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionListWithNamedWithTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionListWithNamedWithTime(this);
}
}
public final ExpressionListWithNamedWithTimeContext expressionListWithNamedWithTime() throws RecognitionException {
ExpressionListWithNamedWithTimeContext _localctx = new ExpressionListWithNamedWithTimeContext(_ctx, getState());
enterRule(_localctx, 420, RULE_expressionListWithNamedWithTime);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2855);
expressionWithNamedWithTime();
setState(2860);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2856);
match(COMMA);
setState(2857);
expressionWithNamedWithTime();
}
}
setState(2862);
_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, 422, RULE_expressionWithNamed);
try {
setState(2865);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,390,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2863);
expressionNamedParameter();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2864);
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, 424, RULE_expressionWithNamedWithTime);
try {
setState(2869);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,391,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2867);
expressionNamedParameterWithTime();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2868);
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, 426, RULE_expressionNamedParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2871);
match(IDENT);
setState(2872);
match(COLON);
setState(2879);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) {
case 1:
{
setState(2873);
expression();
}
break;
case 2:
{
setState(2874);
match(LPAREN);
setState(2876);
_errHandler.sync(this);
_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(2875);
expressionList();
}
}
setState(2878);
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, 428, RULE_expressionNamedParameterWithTime);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2881);
match(IDENT);
setState(2882);
match(COLON);
setState(2889);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,395,_ctx) ) {
case 1:
{
setState(2883);
expressionWithTime();
}
break;
case 2:
{
setState(2884);
match(LPAREN);
setState(2886);
_errHandler.sync(this);
_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(2885);
expressionWithTimeList();
}
}
setState(2888);
match(RPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionList(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 430, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2891);
expression();
setState(2896);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2892);
match(COMMA);
setState(2893);
expression();
}
}
setState(2898);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionWithTimeListContext extends ParserRuleContext {
public List expressionWithTimeInclLast() {
return getRuleContexts(ExpressionWithTimeInclLastContext.class);
}
public ExpressionWithTimeInclLastContext expressionWithTimeInclLast(int i) {
return getRuleContext(ExpressionWithTimeInclLastContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public ExpressionWithTimeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithTimeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterExpressionWithTimeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitExpressionWithTimeList(this);
}
}
public final ExpressionWithTimeListContext expressionWithTimeList() throws RecognitionException {
ExpressionWithTimeListContext _localctx = new ExpressionWithTimeListContext(_ctx, getState());
enterRule(_localctx, 432, RULE_expressionWithTimeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2899);
expressionWithTimeInclLast();
setState(2904);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2900);
match(COMMA);
setState(2901);
expressionWithTimeInclLast();
}
}
setState(2906);
_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, 434, RULE_expressionWithTime);
try {
setState(2917);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,398,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2907);
lastWeekdayOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2908);
timePeriod();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2909);
expressionQualifyable();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2910);
rangeOperand();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2911);
frequencyOperand();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2912);
lastOperator();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2913);
weekDayOperator();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2914);
numericParameterList();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2915);
match(STAR);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2916);
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, 436, RULE_expressionWithTimeInclLast);
try {
setState(2921);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,399,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2919);
lastOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2920);
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, 438, RULE_expressionQualifyable);
try {
enterOuterAlt(_localctx, 1);
{
setState(2923);
expression();
setState(2929);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASC:
{
setState(2924);
((ExpressionQualifyableContext)_localctx).a = match(ASC);
}
break;
case DESC:
{
setState(2925);
((ExpressionQualifyableContext)_localctx).d = match(DESC);
}
break;
case TIMEPERIOD_SECONDS:
{
setState(2926);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SECONDS);
}
break;
case TIMEPERIOD_SECOND:
{
setState(2927);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SECOND);
}
break;
case TIMEPERIOD_SEC:
{
setState(2928);
((ExpressionQualifyableContext)_localctx).s = match(TIMEPERIOD_SEC);
}
break;
case RPAREN:
case COMMA:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastWeekdayOperandContext extends ParserRuleContext {
public TerminalNode LW() { return getToken(EsperEPL2GrammarParser.LW, 0); }
public LastWeekdayOperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastWeekdayOperand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterLastWeekdayOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitLastWeekdayOperand(this);
}
}
public final LastWeekdayOperandContext lastWeekdayOperand() throws RecognitionException {
LastWeekdayOperandContext _localctx = new LastWeekdayOperandContext(_ctx, getState());
enterRule(_localctx, 440, RULE_lastWeekdayOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2931);
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, 442, RULE_lastOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2933);
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, 444, RULE_frequencyOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2935);
match(STAR);
setState(2936);
match(DIV);
setState(2940);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2937);
number();
}
break;
case IDENT:
{
setState(2938);
((FrequencyOperandContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2939);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeOperandContext extends ParserRuleContext {
public NumberContext n1;
public Token i1;
public SubstitutionContext s1;
public NumberContext n2;
public Token i2;
public SubstitutionContext s2;
public TerminalNode COLON() { return getToken(EsperEPL2GrammarParser.COLON, 0); }
public List number() {
return getRuleContexts(NumberContext.class);
}
public NumberContext number(int i) {
return getRuleContext(NumberContext.class,i);
}
public List IDENT() { return getTokens(EsperEPL2GrammarParser.IDENT); }
public TerminalNode IDENT(int i) {
return getToken(EsperEPL2GrammarParser.IDENT, i);
}
public List substitution() {
return getRuleContexts(SubstitutionContext.class);
}
public SubstitutionContext substitution(int i) {
return getRuleContext(SubstitutionContext.class,i);
}
public RangeOperandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeOperand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterRangeOperand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitRangeOperand(this);
}
}
public final RangeOperandContext rangeOperand() throws RecognitionException {
RangeOperandContext _localctx = new RangeOperandContext(_ctx, getState());
enterRule(_localctx, 446, RULE_rangeOperand);
try {
enterOuterAlt(_localctx, 1);
{
setState(2945);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2942);
((RangeOperandContext)_localctx).n1 = number();
}
break;
case IDENT:
{
setState(2943);
((RangeOperandContext)_localctx).i1 = match(IDENT);
}
break;
case QUESTION:
{
setState(2944);
((RangeOperandContext)_localctx).s1 = substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2947);
match(COLON);
setState(2951);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2948);
((RangeOperandContext)_localctx).n2 = number();
}
break;
case IDENT:
{
setState(2949);
((RangeOperandContext)_localctx).i2 = match(IDENT);
}
break;
case QUESTION:
{
setState(2950);
((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, 448, RULE_lastOperator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2956);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2953);
number();
}
break;
case IDENT:
{
setState(2954);
((LastOperatorContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2955);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2958);
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, 450, RULE_weekDayOperator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2963);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(2960);
number();
}
break;
case IDENT:
{
setState(2961);
((WeekDayOperatorContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(2962);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(2965);
match(WEEKDAY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericParameterListContext extends ParserRuleContext {
public TerminalNode LBRACK() { return getToken(EsperEPL2GrammarParser.LBRACK, 0); }
public List numericListParameter() {
return getRuleContexts(NumericListParameterContext.class);
}
public NumericListParameterContext numericListParameter(int i) {
return getRuleContext(NumericListParameterContext.class,i);
}
public TerminalNode RBRACK() { return getToken(EsperEPL2GrammarParser.RBRACK, 0); }
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public NumericParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNumericParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNumericParameterList(this);
}
}
public final NumericParameterListContext numericParameterList() throws RecognitionException {
NumericParameterListContext _localctx = new NumericParameterListContext(_ctx, getState());
enterRule(_localctx, 452, RULE_numericParameterList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2967);
match(LBRACK);
setState(2968);
numericListParameter();
setState(2973);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2969);
match(COMMA);
setState(2970);
numericListParameter();
}
}
setState(2975);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2976);
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, 454, RULE_numericListParameter);
try {
setState(2981);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,407,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2978);
rangeOperand();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2979);
frequencyOperand();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2980);
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 eventPropertyAtomic() {
return getRuleContexts(EventPropertyAtomicContext.class);
}
public EventPropertyAtomicContext eventPropertyAtomic(int i) {
return getRuleContext(EventPropertyAtomicContext.class,i);
}
public List 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, 456, RULE_eventProperty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2983);
eventPropertyAtomic();
setState(2988);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2984);
match(DOT);
setState(2985);
eventPropertyAtomic();
}
}
setState(2990);
_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, 458, RULE_eventPropertyAtomic);
try {
enterOuterAlt(_localctx, 1);
{
setState(2991);
eventPropertyIdent();
setState(3008);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,412,_ctx) ) {
case 1:
{
setState(2992);
((EventPropertyAtomicContext)_localctx).lb = match(LBRACK);
setState(2993);
((EventPropertyAtomicContext)_localctx).ni = number();
setState(2994);
match(RBRACK);
setState(2996);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,409,_ctx) ) {
case 1:
{
setState(2995);
((EventPropertyAtomicContext)_localctx).q = match(QUESTION);
}
break;
}
}
break;
case 2:
{
setState(2998);
((EventPropertyAtomicContext)_localctx).lp = match(LPAREN);
setState(3001);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
{
setState(2999);
((EventPropertyAtomicContext)_localctx).s = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
{
setState(3000);
((EventPropertyAtomicContext)_localctx).s = match(QUOTED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(3003);
match(RPAREN);
setState(3005);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,411,_ctx) ) {
case 1:
{
setState(3004);
((EventPropertyAtomicContext)_localctx).q = match(QUESTION);
}
break;
}
}
break;
case 3:
{
setState(3007);
((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 keywordAllowedIdent() {
return getRuleContexts(KeywordAllowedIdentContext.class);
}
public KeywordAllowedIdentContext keywordAllowedIdent(int i) {
return getRuleContext(KeywordAllowedIdentContext.class,i);
}
public List ESCAPECHAR() { return getTokens(EsperEPL2GrammarParser.ESCAPECHAR); }
public TerminalNode ESCAPECHAR(int i) {
return getToken(EsperEPL2GrammarParser.ESCAPECHAR, i);
}
public List DOT() { return getTokens(EsperEPL2GrammarParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(EsperEPL2GrammarParser.DOT, i);
}
public 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, 460, RULE_eventPropertyIdent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3010);
((EventPropertyIdentContext)_localctx).ipi = keywordAllowedIdent();
setState(3018);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ESCAPECHAR) {
{
{
setState(3011);
match(ESCAPECHAR);
setState(3012);
match(DOT);
setState(3014);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,413,_ctx) ) {
case 1:
{
setState(3013);
((EventPropertyIdentContext)_localctx).ipi2 = keywordAllowedIdent();
}
break;
}
}
}
setState(3020);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentOrTickedContext extends ParserRuleContext {
public Token i1;
public Token i2;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode TICKED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.TICKED_STRING_LITERAL, 0); }
public IdentOrTickedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identOrTicked; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterIdentOrTicked(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitIdentOrTicked(this);
}
}
public final IdentOrTickedContext identOrTicked() throws RecognitionException {
IdentOrTickedContext _localctx = new IdentOrTickedContext(_ctx, getState());
enterRule(_localctx, 462, RULE_identOrTicked);
try {
setState(3023);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3021);
((IdentOrTickedContext)_localctx).i1 = match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3022);
((IdentOrTickedContext)_localctx).i2 = match(TICKED_STRING_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeywordAllowedIdentContext extends ParserRuleContext {
public Token i1;
public Token i2;
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public TerminalNode TICKED_STRING_LITERAL() { return getToken(EsperEPL2GrammarParser.TICKED_STRING_LITERAL, 0); }
public TerminalNode 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, 464, RULE_keywordAllowedIdent);
try {
setState(3077);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3025);
((KeywordAllowedIdentContext)_localctx).i1 = match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3026);
((KeywordAllowedIdentContext)_localctx).i2 = match(TICKED_STRING_LITERAL);
}
break;
case AT:
enterOuterAlt(_localctx, 3);
{
setState(3027);
match(AT);
}
break;
case COUNT:
enterOuterAlt(_localctx, 4);
{
setState(3028);
match(COUNT);
}
break;
case ESCAPE:
enterOuterAlt(_localctx, 5);
{
setState(3029);
match(ESCAPE);
}
break;
case EVERY_EXPR:
enterOuterAlt(_localctx, 6);
{
setState(3030);
match(EVERY_EXPR);
}
break;
case SCHEMA:
enterOuterAlt(_localctx, 7);
{
setState(3031);
match(SCHEMA);
}
break;
case SUM:
enterOuterAlt(_localctx, 8);
{
setState(3032);
match(SUM);
}
break;
case AVG:
enterOuterAlt(_localctx, 9);
{
setState(3033);
match(AVG);
}
break;
case MAX:
enterOuterAlt(_localctx, 10);
{
setState(3034);
match(MAX);
}
break;
case MIN:
enterOuterAlt(_localctx, 11);
{
setState(3035);
match(MIN);
}
break;
case COALESCE:
enterOuterAlt(_localctx, 12);
{
setState(3036);
match(COALESCE);
}
break;
case MEDIAN:
enterOuterAlt(_localctx, 13);
{
setState(3037);
match(MEDIAN);
}
break;
case STDDEV:
enterOuterAlt(_localctx, 14);
{
setState(3038);
match(STDDEV);
}
break;
case AVEDEV:
enterOuterAlt(_localctx, 15);
{
setState(3039);
match(AVEDEV);
}
break;
case EVENTS:
enterOuterAlt(_localctx, 16);
{
setState(3040);
match(EVENTS);
}
break;
case FIRST:
enterOuterAlt(_localctx, 17);
{
setState(3041);
match(FIRST);
}
break;
case LAST:
enterOuterAlt(_localctx, 18);
{
setState(3042);
match(LAST);
}
break;
case WHILE:
enterOuterAlt(_localctx, 19);
{
setState(3043);
match(WHILE);
}
break;
case MERGE:
enterOuterAlt(_localctx, 20);
{
setState(3044);
match(MERGE);
}
break;
case MATCHED:
enterOuterAlt(_localctx, 21);
{
setState(3045);
match(MATCHED);
}
break;
case UNIDIRECTIONAL:
enterOuterAlt(_localctx, 22);
{
setState(3046);
match(UNIDIRECTIONAL);
}
break;
case RETAINUNION:
enterOuterAlt(_localctx, 23);
{
setState(3047);
match(RETAINUNION);
}
break;
case RETAININTERSECTION:
enterOuterAlt(_localctx, 24);
{
setState(3048);
match(RETAININTERSECTION);
}
break;
case UNTIL:
enterOuterAlt(_localctx, 25);
{
setState(3049);
match(UNTIL);
}
break;
case PATTERN:
enterOuterAlt(_localctx, 26);
{
setState(3050);
match(PATTERN);
}
break;
case SQL:
enterOuterAlt(_localctx, 27);
{
setState(3051);
match(SQL);
}
break;
case METADATASQL:
enterOuterAlt(_localctx, 28);
{
setState(3052);
match(METADATASQL);
}
break;
case PREVIOUS:
enterOuterAlt(_localctx, 29);
{
setState(3053);
match(PREVIOUS);
}
break;
case PREVIOUSTAIL:
enterOuterAlt(_localctx, 30);
{
setState(3054);
match(PREVIOUSTAIL);
}
break;
case PRIOR:
enterOuterAlt(_localctx, 31);
{
setState(3055);
match(PRIOR);
}
break;
case WEEKDAY:
enterOuterAlt(_localctx, 32);
{
setState(3056);
match(WEEKDAY);
}
break;
case LW:
enterOuterAlt(_localctx, 33);
{
setState(3057);
match(LW);
}
break;
case INSTANCEOF:
enterOuterAlt(_localctx, 34);
{
setState(3058);
match(INSTANCEOF);
}
break;
case TYPEOF:
enterOuterAlt(_localctx, 35);
{
setState(3059);
match(TYPEOF);
}
break;
case CAST:
enterOuterAlt(_localctx, 36);
{
setState(3060);
match(CAST);
}
break;
case SNAPSHOT:
enterOuterAlt(_localctx, 37);
{
setState(3061);
match(SNAPSHOT);
}
break;
case VARIABLE:
enterOuterAlt(_localctx, 38);
{
setState(3062);
match(VARIABLE);
}
break;
case TABLE:
enterOuterAlt(_localctx, 39);
{
setState(3063);
match(TABLE);
}
break;
case INDEX:
enterOuterAlt(_localctx, 40);
{
setState(3064);
match(INDEX);
}
break;
case WINDOW:
enterOuterAlt(_localctx, 41);
{
setState(3065);
match(WINDOW);
}
break;
case LEFT:
enterOuterAlt(_localctx, 42);
{
setState(3066);
match(LEFT);
}
break;
case RIGHT:
enterOuterAlt(_localctx, 43);
{
setState(3067);
match(RIGHT);
}
break;
case OUTER:
enterOuterAlt(_localctx, 44);
{
setState(3068);
match(OUTER);
}
break;
case FULL:
enterOuterAlt(_localctx, 45);
{
setState(3069);
match(FULL);
}
break;
case JOIN:
enterOuterAlt(_localctx, 46);
{
setState(3070);
match(JOIN);
}
break;
case DEFINE:
enterOuterAlt(_localctx, 47);
{
setState(3071);
match(DEFINE);
}
break;
case PARTITION:
enterOuterAlt(_localctx, 48);
{
setState(3072);
match(PARTITION);
}
break;
case MATCHES:
enterOuterAlt(_localctx, 49);
{
setState(3073);
match(MATCHES);
}
break;
case CONTEXT:
enterOuterAlt(_localctx, 50);
{
setState(3074);
match(CONTEXT);
}
break;
case FOR:
enterOuterAlt(_localctx, 51);
{
setState(3075);
match(FOR);
}
break;
case USING:
enterOuterAlt(_localctx, 52);
{
setState(3076);
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, 466, RULE_escapableStr);
try {
setState(3082);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3079);
((EscapableStrContext)_localctx).i1 = match(IDENT);
}
break;
case EVENTS:
enterOuterAlt(_localctx, 2);
{
setState(3080);
((EscapableStrContext)_localctx).i2 = match(EVENTS);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(3081);
((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, 468, RULE_escapableIdent);
try {
setState(3086);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENT:
enterOuterAlt(_localctx, 1);
{
setState(3084);
match(IDENT);
}
break;
case TICKED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3085);
((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, 470, RULE_timePeriod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,455,_ctx) ) {
case 1:
{
setState(3088);
yearPart();
setState(3090);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,419,_ctx) ) {
case 1:
{
setState(3089);
monthPart();
}
break;
}
setState(3093);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,420,_ctx) ) {
case 1:
{
setState(3092);
weekPart();
}
break;
}
setState(3096);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) {
case 1:
{
setState(3095);
dayPart();
}
break;
}
setState(3099);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) {
case 1:
{
setState(3098);
hourPart();
}
break;
}
setState(3102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,423,_ctx) ) {
case 1:
{
setState(3101);
minutePart();
}
break;
}
setState(3105);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,424,_ctx) ) {
case 1:
{
setState(3104);
secondPart();
}
break;
}
setState(3108);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,425,_ctx) ) {
case 1:
{
setState(3107);
millisecondPart();
}
break;
}
setState(3111);
_errHandler.sync(this);
_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(3110);
microsecondPart();
}
}
}
break;
case 2:
{
setState(3113);
monthPart();
setState(3115);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,427,_ctx) ) {
case 1:
{
setState(3114);
weekPart();
}
break;
}
setState(3118);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,428,_ctx) ) {
case 1:
{
setState(3117);
dayPart();
}
break;
}
setState(3121);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,429,_ctx) ) {
case 1:
{
setState(3120);
hourPart();
}
break;
}
setState(3124);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,430,_ctx) ) {
case 1:
{
setState(3123);
minutePart();
}
break;
}
setState(3127);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,431,_ctx) ) {
case 1:
{
setState(3126);
secondPart();
}
break;
}
setState(3130);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,432,_ctx) ) {
case 1:
{
setState(3129);
millisecondPart();
}
break;
}
setState(3133);
_errHandler.sync(this);
_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(3132);
microsecondPart();
}
}
}
break;
case 3:
{
setState(3135);
weekPart();
setState(3137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,434,_ctx) ) {
case 1:
{
setState(3136);
dayPart();
}
break;
}
setState(3140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,435,_ctx) ) {
case 1:
{
setState(3139);
hourPart();
}
break;
}
setState(3143);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,436,_ctx) ) {
case 1:
{
setState(3142);
minutePart();
}
break;
}
setState(3146);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,437,_ctx) ) {
case 1:
{
setState(3145);
secondPart();
}
break;
}
setState(3149);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,438,_ctx) ) {
case 1:
{
setState(3148);
millisecondPart();
}
break;
}
setState(3152);
_errHandler.sync(this);
_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(3151);
microsecondPart();
}
}
}
break;
case 4:
{
setState(3154);
dayPart();
setState(3156);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,440,_ctx) ) {
case 1:
{
setState(3155);
hourPart();
}
break;
}
setState(3159);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,441,_ctx) ) {
case 1:
{
setState(3158);
minutePart();
}
break;
}
setState(3162);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,442,_ctx) ) {
case 1:
{
setState(3161);
secondPart();
}
break;
}
setState(3165);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,443,_ctx) ) {
case 1:
{
setState(3164);
millisecondPart();
}
break;
}
setState(3168);
_errHandler.sync(this);
_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(3167);
microsecondPart();
}
}
}
break;
case 5:
{
setState(3170);
hourPart();
setState(3172);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,445,_ctx) ) {
case 1:
{
setState(3171);
minutePart();
}
break;
}
setState(3175);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,446,_ctx) ) {
case 1:
{
setState(3174);
secondPart();
}
break;
}
setState(3178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,447,_ctx) ) {
case 1:
{
setState(3177);
millisecondPart();
}
break;
}
setState(3181);
_errHandler.sync(this);
_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(3180);
microsecondPart();
}
}
}
break;
case 6:
{
setState(3183);
minutePart();
setState(3185);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,449,_ctx) ) {
case 1:
{
setState(3184);
secondPart();
}
break;
}
setState(3188);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,450,_ctx) ) {
case 1:
{
setState(3187);
millisecondPart();
}
break;
}
setState(3191);
_errHandler.sync(this);
_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(3190);
microsecondPart();
}
}
}
break;
case 7:
{
setState(3193);
secondPart();
setState(3195);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,452,_ctx) ) {
case 1:
{
setState(3194);
millisecondPart();
}
break;
}
setState(3198);
_errHandler.sync(this);
_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(3197);
microsecondPart();
}
}
}
break;
case 8:
{
setState(3200);
millisecondPart();
setState(3202);
_errHandler.sync(this);
_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(3201);
microsecondPart();
}
}
}
break;
case 9:
{
setState(3204);
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, 472, RULE_yearPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3210);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3207);
numberconstant();
}
break;
case IDENT:
{
setState(3208);
((YearPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3209);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3212);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_YEAR || _la==TIMEPERIOD_YEARS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MonthPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MONTHS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MONTHS, 0); }
public TerminalNode TIMEPERIOD_MONTH() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MONTH, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MonthPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_monthPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMonthPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMonthPart(this);
}
}
public final MonthPartContext monthPart() throws RecognitionException {
MonthPartContext _localctx = new MonthPartContext(_ctx, getState());
enterRule(_localctx, 474, RULE_monthPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3217);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3214);
numberconstant();
}
break;
case IDENT:
{
setState(3215);
((MonthPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3216);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3219);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_MONTH || _la==TIMEPERIOD_MONTHS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WeekPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_WEEKS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_WEEKS, 0); }
public TerminalNode TIMEPERIOD_WEEK() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_WEEK, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public WeekPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_weekPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterWeekPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitWeekPart(this);
}
}
public final WeekPartContext weekPart() throws RecognitionException {
WeekPartContext _localctx = new WeekPartContext(_ctx, getState());
enterRule(_localctx, 476, RULE_weekPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3224);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3221);
numberconstant();
}
break;
case IDENT:
{
setState(3222);
((WeekPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3223);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3226);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_WEEK || _la==TIMEPERIOD_WEEKS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DayPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_DAYS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_DAYS, 0); }
public TerminalNode TIMEPERIOD_DAY() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_DAY, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public DayPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dayPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterDayPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitDayPart(this);
}
}
public final DayPartContext dayPart() throws RecognitionException {
DayPartContext _localctx = new DayPartContext(_ctx, getState());
enterRule(_localctx, 478, RULE_dayPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3231);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3228);
numberconstant();
}
break;
case IDENT:
{
setState(3229);
((DayPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3230);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3233);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_DAY || _la==TIMEPERIOD_DAYS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HourPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_HOURS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_HOURS, 0); }
public TerminalNode TIMEPERIOD_HOUR() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_HOUR, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public HourPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hourPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterHourPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitHourPart(this);
}
}
public final HourPartContext hourPart() throws RecognitionException {
HourPartContext _localctx = new HourPartContext(_ctx, getState());
enterRule(_localctx, 480, RULE_hourPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3238);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3235);
numberconstant();
}
break;
case IDENT:
{
setState(3236);
((HourPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3237);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3240);
_la = _input.LA(1);
if ( !(_la==TIMEPERIOD_HOUR || _la==TIMEPERIOD_HOURS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MinutePartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MINUTES() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MINUTES, 0); }
public TerminalNode TIMEPERIOD_MINUTE() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MINUTE, 0); }
public TerminalNode MIN() { return getToken(EsperEPL2GrammarParser.MIN, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MinutePartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minutePart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMinutePart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMinutePart(this);
}
}
public final MinutePartContext minutePart() throws RecognitionException {
MinutePartContext _localctx = new MinutePartContext(_ctx, getState());
enterRule(_localctx, 482, RULE_minutePart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3245);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3242);
numberconstant();
}
break;
case IDENT:
{
setState(3243);
((MinutePartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3244);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3247);
_la = _input.LA(1);
if ( !(_la==MIN || _la==TIMEPERIOD_MINUTE || _la==TIMEPERIOD_MINUTES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SecondPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_SECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SECONDS, 0); }
public TerminalNode TIMEPERIOD_SECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SECOND, 0); }
public TerminalNode TIMEPERIOD_SEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_SEC, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public SecondPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_secondPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSecondPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSecondPart(this);
}
}
public final SecondPartContext secondPart() throws RecognitionException {
SecondPartContext _localctx = new SecondPartContext(_ctx, getState());
enterRule(_localctx, 484, RULE_secondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3252);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3249);
numberconstant();
}
break;
case IDENT:
{
setState(3250);
((SecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3251);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3254);
_la = _input.LA(1);
if ( !(((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & ((1L << (TIMEPERIOD_SEC - 98)) | (1L << (TIMEPERIOD_SECOND - 98)) | (1L << (TIMEPERIOD_SECONDS - 98)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MillisecondPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MILLISECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MILLISECONDS, 0); }
public TerminalNode TIMEPERIOD_MILLISECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MILLISECOND, 0); }
public TerminalNode TIMEPERIOD_MILLISEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MILLISEC, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MillisecondPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_millisecondPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMillisecondPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMillisecondPart(this);
}
}
public final MillisecondPartContext millisecondPart() throws RecognitionException {
MillisecondPartContext _localctx = new MillisecondPartContext(_ctx, getState());
enterRule(_localctx, 486, RULE_millisecondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3259);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3256);
numberconstant();
}
break;
case IDENT:
{
setState(3257);
((MillisecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3258);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3261);
_la = _input.LA(1);
if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (TIMEPERIOD_MILLISEC - 101)) | (1L << (TIMEPERIOD_MILLISECOND - 101)) | (1L << (TIMEPERIOD_MILLISECONDS - 101)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MicrosecondPartContext extends ParserRuleContext {
public Token i;
public TerminalNode TIMEPERIOD_MICROSECONDS() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MICROSECONDS, 0); }
public TerminalNode TIMEPERIOD_MICROSECOND() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MICROSECOND, 0); }
public TerminalNode TIMEPERIOD_MICROSEC() { return getToken(EsperEPL2GrammarParser.TIMEPERIOD_MICROSEC, 0); }
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public SubstitutionContext substitution() {
return getRuleContext(SubstitutionContext.class,0);
}
public TerminalNode IDENT() { return getToken(EsperEPL2GrammarParser.IDENT, 0); }
public MicrosecondPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_microsecondPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterMicrosecondPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitMicrosecondPart(this);
}
}
public final MicrosecondPartContext microsecondPart() throws RecognitionException {
MicrosecondPartContext _localctx = new MicrosecondPartContext(_ctx, getState());
enterRule(_localctx, 488, RULE_microsecondPart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3266);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
{
setState(3263);
numberconstant();
}
break;
case IDENT:
{
setState(3264);
((MicrosecondPartContext)_localctx).i = match(IDENT);
}
break;
case QUESTION:
{
setState(3265);
substitution();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3268);
_la = _input.LA(1);
if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (TIMEPERIOD_MICROSEC - 104)) | (1L << (TIMEPERIOD_MICROSECOND - 104)) | (1L << (TIMEPERIOD_MICROSECONDS - 104)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberContext extends ParserRuleContext {
public TerminalNode IntegerLiteral() { return getToken(EsperEPL2GrammarParser.IntegerLiteral, 0); }
public TerminalNode FloatingPointLiteral() { return getToken(EsperEPL2GrammarParser.FloatingPointLiteral, 0); }
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitNumber(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 490, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3270);
_la = _input.LA(1);
if ( !(_la==IntegerLiteral || _la==FloatingPointLiteral) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubstitutionContext extends ParserRuleContext {
public Token q;
public TerminalNode QUESTION() { return getToken(EsperEPL2GrammarParser.QUESTION, 0); }
public List COLON() { return getTokens(EsperEPL2GrammarParser.COLON); }
public TerminalNode COLON(int i) {
return getToken(EsperEPL2GrammarParser.COLON, i);
}
public SubstitutionSlashIdentContext substitutionSlashIdent() {
return getRuleContext(SubstitutionSlashIdentContext.class,0);
}
public ClassIdentifierWithDimensionsContext classIdentifierWithDimensions() {
return getRuleContext(ClassIdentifierWithDimensionsContext.class,0);
}
public SubstitutionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substitution; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubstitution(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubstitution(this);
}
}
public final SubstitutionContext substitution() throws RecognitionException {
SubstitutionContext _localctx = new SubstitutionContext(_ctx, getState());
enterRule(_localctx, 492, RULE_substitution);
try {
enterOuterAlt(_localctx, 1);
{
setState(3272);
((SubstitutionContext)_localctx).q = match(QUESTION);
setState(3281);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,467,_ctx) ) {
case 1:
{
setState(3273);
match(COLON);
setState(3275);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,465,_ctx) ) {
case 1:
{
setState(3274);
substitutionSlashIdent();
}
break;
}
setState(3279);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,466,_ctx) ) {
case 1:
{
setState(3277);
match(COLON);
setState(3278);
classIdentifierWithDimensions();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubstitutionSlashIdentContext extends ParserRuleContext {
public Token d;
public EscapableStrContext i1;
public EscapableStrContext i2;
public List escapableStr() {
return getRuleContexts(EscapableStrContext.class);
}
public EscapableStrContext escapableStr(int i) {
return getRuleContext(EscapableStrContext.class,i);
}
public List DIV() { return getTokens(EsperEPL2GrammarParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(EsperEPL2GrammarParser.DIV, i);
}
public SubstitutionSlashIdentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substitutionSlashIdent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterSubstitutionSlashIdent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitSubstitutionSlashIdent(this);
}
}
public final SubstitutionSlashIdentContext substitutionSlashIdent() throws RecognitionException {
SubstitutionSlashIdentContext _localctx = new SubstitutionSlashIdentContext(_ctx, getState());
enterRule(_localctx, 494, RULE_substitutionSlashIdent);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3284);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DIV) {
{
setState(3283);
((SubstitutionSlashIdentContext)_localctx).d = match(DIV);
}
}
setState(3286);
((SubstitutionSlashIdentContext)_localctx).i1 = escapableStr();
setState(3291);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,469,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3287);
match(DIV);
setState(3288);
((SubstitutionSlashIdentContext)_localctx).i2 = escapableStr();
}
}
}
setState(3293);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,469,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantContext extends ParserRuleContext {
public Token t;
public Token f;
public Token nu;
public NumberconstantContext numberconstant() {
return getRuleContext(NumberconstantContext.class,0);
}
public StringconstantContext stringconstant() {
return getRuleContext(StringconstantContext.class,0);
}
public TerminalNode BOOLEAN_TRUE() { return getToken(EsperEPL2GrammarParser.BOOLEAN_TRUE, 0); }
public TerminalNode BOOLEAN_FALSE() { return getToken(EsperEPL2GrammarParser.BOOLEAN_FALSE, 0); }
public TerminalNode VALUE_NULL() { return getToken(EsperEPL2GrammarParser.VALUE_NULL, 0); }
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitConstant(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 496, RULE_constant);
try {
setState(3299);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 1);
{
setState(3294);
numberconstant();
}
break;
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3295);
stringconstant();
}
break;
case BOOLEAN_TRUE:
enterOuterAlt(_localctx, 3);
{
setState(3296);
((ConstantContext)_localctx).t = match(BOOLEAN_TRUE);
}
break;
case BOOLEAN_FALSE:
enterOuterAlt(_localctx, 4);
{
setState(3297);
((ConstantContext)_localctx).f = match(BOOLEAN_FALSE);
}
break;
case VALUE_NULL:
enterOuterAlt(_localctx, 5);
{
setState(3298);
((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, 498, RULE_numberconstant);
try {
enterOuterAlt(_localctx, 1);
{
setState(3303);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MINUS:
{
setState(3301);
((NumberconstantContext)_localctx).m = match(MINUS);
}
break;
case PLUS:
{
setState(3302);
((NumberconstantContext)_localctx).p = match(PLUS);
}
break;
case IntegerLiteral:
case FloatingPointLiteral:
break;
default:
break;
}
setState(3305);
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, 500, RULE_stringconstant);
try {
setState(3309);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(3307);
((StringconstantContext)_localctx).sl = match(STRING_LITERAL);
}
break;
case QUOTED_STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(3308);
((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, 502, RULE_jsonvalue);
try {
setState(3314);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLEAN_TRUE:
case BOOLEAN_FALSE:
case VALUE_NULL:
case PLUS:
case MINUS:
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
case IntegerLiteral:
case FloatingPointLiteral:
enterOuterAlt(_localctx, 1);
{
setState(3311);
constant();
}
break;
case LCURLY:
enterOuterAlt(_localctx, 2);
{
setState(3312);
jsonobject();
}
break;
case LBRACK:
enterOuterAlt(_localctx, 3);
{
setState(3313);
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, 504, RULE_jsonobject);
try {
enterOuterAlt(_localctx, 1);
{
setState(3316);
match(LCURLY);
setState(3317);
jsonmembers();
setState(3318);
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, 506, RULE_jsonarray);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3320);
match(LBRACK);
setState(3322);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (BOOLEAN_TRUE - 107)) | (1L << (BOOLEAN_FALSE - 107)) | (1L << (VALUE_NULL - 107)) | (1L << (LBRACK - 107)) | (1L << (LCURLY - 107)) | (1L << (PLUS - 107)) | (1L << (MINUS - 107)))) != 0) || ((((_la - 193)) & ~0x3f) == 0 && ((1L << (_la - 193)) & ((1L << (QUOTED_STRING_LITERAL - 193)) | (1L << (STRING_LITERAL - 193)) | (1L << (IntegerLiteral - 193)) | (1L << (FloatingPointLiteral - 193)))) != 0)) {
{
setState(3321);
jsonelements();
}
}
setState(3324);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonelementsContext extends ParserRuleContext {
public List jsonvalue() {
return getRuleContexts(JsonvalueContext.class);
}
public JsonvalueContext jsonvalue(int i) {
return getRuleContext(JsonvalueContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public JsonelementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonelements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonelements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonelements(this);
}
}
public final JsonelementsContext jsonelements() throws RecognitionException {
JsonelementsContext _localctx = new JsonelementsContext(_ctx, getState());
enterRule(_localctx, 508, RULE_jsonelements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3326);
jsonvalue();
setState(3331);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,475,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3327);
match(COMMA);
setState(3328);
jsonvalue();
}
}
}
setState(3333);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,475,_ctx);
}
setState(3335);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(3334);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JsonmembersContext extends ParserRuleContext {
public List jsonpair() {
return getRuleContexts(JsonpairContext.class);
}
public JsonpairContext jsonpair(int i) {
return getRuleContext(JsonpairContext.class,i);
}
public List COMMA() { return getTokens(EsperEPL2GrammarParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EsperEPL2GrammarParser.COMMA, i);
}
public JsonmembersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonmembers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).enterJsonmembers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsperEPL2GrammarListener ) ((EsperEPL2GrammarListener)listener).exitJsonmembers(this);
}
}
public final JsonmembersContext jsonmembers() throws RecognitionException {
JsonmembersContext _localctx = new JsonmembersContext(_ctx, getState());
enterRule(_localctx, 510, RULE_jsonmembers);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3337);
jsonpair();
setState(3342);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,477,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(3338);
match(COMMA);
setState(3339);
jsonpair();
}
}
}
setState(3344);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,477,_ctx);
}
setState(3346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(3345);
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, 512, RULE_jsonpair);
try {
enterOuterAlt(_localctx, 1);
{
setState(3350);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUOTED_STRING_LITERAL:
case STRING_LITERAL:
{
setState(3348);
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(3349);
keywordAllowedIdent();
}
break;
default:
throw new NoViableAltException(this);
}
setState(3352);
match(COLON);
setState(3353);
jsonvalue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
private static final int _serializedATNSegments = 2;
private static final String _serializedATNSegment0 =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00c7\u0d1e\4\2\t"+
"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+
"\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+
"\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+
"\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+
"\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+
"\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+
"\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+
"\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+
"\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+
"\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+
"\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+
"\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+
"\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+
"\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+
"\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+
"\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+
"\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+
"\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+
"\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+
"\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1"+
"\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5"+
"\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa"+
"\t\u00fa\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe"+
"\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101\4\u0102\t\u0102\3\2\3"+
"\2\7\2\u0207\n\2\f\2\16\2\u020a\13\2\3\2\3\2\3\2\3\3\3\3\3\3\3\4\3\4\3"+
"\4\3\5\3\5\5\5\u0217\n\5\3\5\3\5\5\5\u021b\n\5\3\5\5\5\u021e\n\5\3\5\5"+
"\5\u0221\n\5\3\5\3\5\3\5\5\5\u0226\n\5\3\5\5\5\u0229\n\5\3\5\3\5\5\5\u022d"+
"\n\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\5\7\u0236\n\7\3\7\3\7\3\7\3\7\3\7\3\7"+
"\3\7\5\7\u023f\n\7\3\b\3\b\3\b\3\b\3\b\5\b\u0246\n\b\3\b\3\b\3\t\3\t\3"+
"\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\5\n\u0255\n\n\3\n\5\n\u0258\n\n\3\13"+
"\3\13\3\13\7\13\u025d\n\13\f\13\16\13\u0260\13\13\3\f\3\f\3\f\3\f\3\r"+
"\3\r\3\r\3\r\3\r\5\r\u026b\n\r\3\16\3\16\3\16\3\16\7\16\u0271\n\16\f\16"+
"\16\16\u0274\13\16\5\16\u0276\n\16\3\16\5\16\u0279\n\16\3\16\3\16\3\17"+
"\5\17\u027e\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\5\17\u028e\n\17\3\17\5\17\u0291\n\17\3\20\3\20\3\20\3"+
"\21\3\21\5\21\u0298\n\21\3\21\3\21\5\21\u029c\n\21\3\21\3\21\3\21\3\21"+
"\5\21\u02a2\n\21\3\21\5\21\u02a5\n\21\3\21\3\21\5\21\u02a9\n\21\3\21\3"+
"\21\3\21\5\21\u02ae\n\21\3\21\3\21\5\21\u02b2\n\21\3\21\3\21\5\21\u02b6"+
"\n\21\3\21\3\21\3\21\5\21\u02bb\n\21\3\21\3\21\5\21\u02bf\n\21\3\22\3"+
"\22\3\22\3\22\3\22\6\22\u02c6\n\22\r\22\16\22\u02c7\3\22\5\22\u02cb\n"+
"\22\5\22\u02cd\n\22\3\22\3\22\3\22\5\22\u02d2\n\22\3\23\3\23\5\23\u02d6"+
"\n\23\3\23\3\23\3\23\5\23\u02db\n\23\3\24\3\24\3\24\3\24\3\25\3\25\3\25"+
"\3\25\5\25\u02e5\n\25\3\25\3\25\3\25\3\25\5\25\u02eb\n\25\3\26\3\26\5"+
"\26\u02ef\n\26\3\26\3\26\3\26\3\26\5\26\u02f5\n\26\3\26\3\26\3\26\5\26"+
"\u02fa\n\26\3\26\6\26\u02fd\n\26\r\26\16\26\u02fe\5\26\u0301\n\26\3\27"+
"\3\27\5\27\u0305\n\27\3\30\3\30\3\30\3\30\5\30\u030b\n\30\3\30\6\30\u030e"+
"\n\30\r\30\16\30\u030f\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0319\n"+
"\31\3\31\3\31\3\31\5\31\u031e\n\31\3\31\5\31\u0321\n\31\3\32\3\32\3\32"+
"\3\32\3\32\5\32\u0328\n\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\5\33"+
"\u0332\n\33\3\33\6\33\u0335\n\33\r\33\16\33\u0336\3\34\3\34\3\34\3\35"+
"\3\35\3\35\5\35\u033f\n\35\3\35\3\35\3\35\3\35\5\35\u0345\n\35\3\35\3"+
"\35\3\35\3\35\5\35\u034b\n\35\3\36\3\36\5\36\u034f\n\36\3\36\3\36\5\36"+
"\u0353\n\36\3\36\5\36\u0356\n\36\3\36\5\36\u0359\n\36\3\36\3\36\5\36\u035d"+
"\n\36\3\36\3\36\5\36\u0361\n\36\3\36\3\36\3\36\5\36\u0366\n\36\3\36\3"+
"\36\5\36\u036a\n\36\3\36\3\36\3\36\5\36\u036f\n\36\3\36\3\36\5\36\u0373"+
"\n\36\3\37\3\37\3\37\3\37\3\37\5\37\u037a\n\37\3\37\3\37\3\37\3\37\5\37"+
"\u0380\n\37\3 \3 \3 \3 \3 \5 \u0387\n \3 \3 \5 \u038b\n \3!\3!\3!\3!\3"+
"!\5!\u0392\n!\3\"\3\"\3\"\5\"\u0397\n\"\3#\3#\3#\3#\5#\u039d\n#\3$\3$"+
"\3$\3%\3%\3%\7%\u03a5\n%\f%\16%\u03a8\13%\3&\3&\3&\3&\3&\5&\u03af\n&\3"+
"\'\3\'\3\'\3\'\3\'\5\'\u03b6\n\'\3(\3(\3(\3(\5(\u03bc\n(\3(\3(\5(\u03c0"+
"\n(\3(\5(\u03c3\n(\3(\3(\3(\3(\3(\5(\u03ca\n(\3(\3(\3(\5(\u03cf\n(\5("+
"\u03d1\n(\3)\3)\3)\3)\5)\u03d7\n)\3)\3)\3*\3*\5*\u03dd\n*\3*\3*\3*\3*"+
"\3*\3*\3*\3*\3+\3+\3+\7+\u03ea\n+\f+\16+\u03ed\13+\3,\3,\3,\5,\u03f2\n"+
",\3,\5,\u03f5\n,\3,\3,\3,\5,\u03fa\n,\3,\5,\u03fd\n,\5,\u03ff\n,\3-\3"+
"-\5-\u0403\n-\3-\3-\3-\3-\3-\5-\u040a\n-\3.\3.\3.\3.\5.\u0410\n.\3.\3"+
".\3.\3.\3/\3/\3/\7/\u0419\n/\f/\16/\u041c\13/\3\60\3\60\3\60\3\60\5\60"+
"\u0422\n\60\3\60\5\60\u0425\n\60\3\60\5\60\u0428\n\60\3\60\3\60\7\60\u042c"+
"\n\60\f\60\16\60\u042f\13\60\3\61\3\61\3\61\7\61\u0434\n\61\f\61\16\61"+
"\u0437\13\61\3\62\3\62\3\62\5\62\u043c\n\62\3\63\3\63\3\63\7\63\u0441"+
"\n\63\f\63\16\63\u0444\13\63\3\64\3\64\3\64\3\64\5\64\u044a\n\64\3\64"+
"\3\64\3\64\3\64\5\64\u0450\n\64\3\65\3\65\5\65\u0454\n\65\3\65\3\65\3"+
"\66\3\66\3\66\5\66\u045b\n\66\3\66\3\66\3\66\5\66\u0460\n\66\3\66\5\66"+
"\u0463\n\66\3\66\7\66\u0466\n\66\f\66\16\66\u0469\13\66\3\67\3\67\3\67"+
"\3\67\3\67\3\67\5\67\u0471\n\67\3\67\3\67\5\67\u0475\n\67\38\38\38\39"+
"\39\39\39\39\39\39\3:\3:\3:\3:\5:\u0485\n:\3:\3:\3;\3;\7;\u048b\n;\f;"+
"\16;\u048e\13;\3<\7<\u0491\n<\f<\16<\u0494\13<\3<\3<\5<\u0498\n<\3<\5"+
"<\u049b\n<\3<\5<\u049e\n<\3<\3<\5<\u04a2\n<\3<\5<\u04a5\n<\3<\3<\3<\3"+
"<\5<\u04ab\n<\3=\3=\3=\3=\3>\3>\3>\7>\u04b4\n>\f>\16>\u04b7\13>\3?\3?"+
"\5?\u04bb\n?\3?\5?\u04be\n?\3@\3@\3@\3@\3@\3@\3@\3A\3A\3A\3B\3B\3B\3B"+
"\7B\u04ce\nB\fB\16B\u04d1\13B\3C\3C\5C\u04d5\nC\3D\3D\3D\3D\7D\u04db\n"+
"D\fD\16D\u04de\13D\3D\3D\3E\3E\5E\u04e4\nE\3F\3F\5F\u04e8\nF\3G\3G\3G"+
"\7G\u04ed\nG\fG\16G\u04f0\13G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\5H\u04fd"+
"\nH\5H\u04ff\nH\3I\3I\3I\3I\5I\u0505\nI\3I\3I\3J\3J\3J\3K\3K\3K\3K\3K"+
"\3K\7K\u0512\nK\fK\16K\u0515\13K\5K\u0517\nK\3L\3L\3L\5L\u051c\nL\3L\3"+
"L\3M\3M\3M\3M\5M\u0524\nM\3M\3M\5M\u0528\nM\3M\3M\5M\u052c\nM\3M\5M\u052f"+
"\nM\3M\3M\3M\5M\u0534\nM\3M\3M\3M\5M\u0539\nM\3M\5M\u053c\nM\3M\3M\5M"+
"\u0540\nM\3M\3M\3M\7M\u0545\nM\fM\16M\u0548\13M\3M\5M\u054b\nM\3M\5M\u054e"+
"\nM\3M\3M\3M\7M\u0553\nM\fM\16M\u0556\13M\3M\3M\3M\3M\3M\5M\u055d\nM\3"+
"M\3M\3M\7M\u0562\nM\fM\16M\u0565\13M\3M\3M\3M\5M\u056a\nM\5M\u056c\nM"+
"\3N\3N\3N\5N\u0571\nN\3N\3N\3O\3O\3O\3O\5O\u0579\nO\3O\3O\3O\5O\u057e"+
"\nO\3P\3P\5P\u0582\nP\3P\5P\u0585\nP\3Q\3Q\3Q\7Q\u058a\nQ\fQ\16Q\u058d"+
"\13Q\3Q\3Q\3Q\5Q\u0592\nQ\3Q\5Q\u0595\nQ\3R\3R\3R\3R\3S\3S\5S\u059d\n"+
"S\3S\3S\3S\3S\3T\3T\5T\u05a5\nT\3T\3T\3T\7T\u05aa\nT\fT\16T\u05ad\13T"+
"\3U\3U\5U\u05b1\nU\3U\3U\3V\3V\3V\3W\3W\3W\7W\u05bb\nW\fW\16W\u05be\13"+
"W\3X\3X\5X\u05c2\nX\3Y\3Y\3Y\3Z\3Z\3Z\5Z\u05ca\nZ\3Z\3Z\3Z\3Z\5Z\u05d0"+
"\nZ\3Z\5Z\u05d3\nZ\3[\3[\3[\7[\u05d8\n[\f[\16[\u05db\13[\3\\\3\\\3\\\5"+
"\\\u05e0\n\\\3]\3]\7]\u05e4\n]\f]\16]\u05e7\13]\3^\3^\7^\u05eb\n^\f^\16"+
"^\u05ee\13^\3_\3_\3_\5_\u05f3\n_\3_\5_\u05f6\n_\3_\5_\u05f9\n_\3_\3_\3"+
"_\5_\u05fe\n_\3`\3`\3`\3`\7`\u0604\n`\f`\16`\u0607\13`\3a\3a\3a\3a\3b"+
"\3b\3c\3c\3c\5c\u0612\nc\3c\5c\u0615\nc\3c\3c\3d\3d\3d\7d\u061c\nd\fd"+
"\16d\u061f\13d\3e\3e\3e\5e\u0624\ne\3f\3f\5f\u0628\nf\3f\5f\u062b\nf\3"+
"f\5f\u062e\nf\3g\3g\3g\3h\3h\3h\3h\3h\5h\u0638\nh\3i\3i\3i\3i\5i\u063e"+
"\ni\3i\5i\u0641\ni\3i\3i\3i\5i\u0646\ni\3i\5i\u0649\ni\3i\3i\5i\u064d"+
"\ni\3j\3j\3j\3j\5j\u0653\nj\3j\5j\u0656\nj\3k\3k\7k\u065a\nk\fk\16k\u065d"+
"\13k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\5l\u0669\nl\3l\3l\3l\5l\u066e\nl\5"+
"l\u0670\nl\3l\3l\3m\3m\3m\3m\3m\5m\u0679\nm\3m\5m\u067c\nm\3m\5m\u067f"+
"\nm\3n\3n\3n\3n\7n\u0685\nn\fn\16n\u0688\13n\3n\3n\3n\3n\7n\u068e\nn\f"+
"n\16n\u0691\13n\5n\u0693\nn\3o\3o\3o\3o\3p\3p\5p\u069b\np\3p\3p\3q\3q"+
"\5q\u06a1\nq\3q\3q\5q\u06a5\nq\3q\5q\u06a8\nq\3r\3r\3r\7r\u06ad\nr\fr"+
"\16r\u06b0\13r\3s\3s\3s\5s\u06b5\ns\3t\3t\3t\3t\3t\7t\u06bc\nt\ft\16t"+
"\u06bf\13t\3t\3t\3u\3u\3u\3u\3u\3u\7u\u06c9\nu\fu\16u\u06cc\13u\3u\3u"+
"\3v\3v\5v\u06d2\nv\3w\3w\3w\3w\3w\7w\u06d9\nw\fw\16w\u06dc\13w\5w\u06de"+
"\nw\3w\5w\u06e1\nw\3x\3x\3x\7x\u06e6\nx\fx\16x\u06e9\13x\3y\3y\3y\5y\u06ee"+
"\ny\3z\3z\3{\5{\u06f3\n{\3{\3{\3{\3{\5{\u06f9\n{\3{\3{\3{\3{\5{\u06ff"+
"\n{\3{\5{\u0702\n{\3{\3{\3{\3{\3{\3{\5{\u070a\n{\3{\3{\3{\3{\5{\u0710"+
"\n{\3{\3{\5{\u0714\n{\3{\5{\u0717\n{\3{\5{\u071a\n{\3|\3|\3|\3|\3|\5|"+
"\u0721\n|\3|\3|\5|\u0725\n|\3}\3}\3}\3}\3}\5}\u072c\n}\3~\3~\5~\u0730"+
"\n~\3~\3~\5~\u0734\n~\3~\3~\5~\u0738\n~\5~\u073a\n~\3\177\3\177\3\177"+
"\7\177\u073f\n\177\f\177\16\177\u0742\13\177\3\u0080\3\u0080\3\u0080\3"+
"\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082\3\u0082"+
"\3\u0083\3\u0083\3\u0083\5\u0083\u0753\n\u0083\3\u0083\3\u0083\5\u0083"+
"\u0757\n\u0083\3\u0083\5\u0083\u075a\n\u0083\3\u0083\3\u0083\5\u0083\u075e"+
"\n\u0083\3\u0083\5\u0083\u0761\n\u0083\3\u0083\3\u0083\3\u0084\3\u0084"+
"\3\u0084\3\u0084\3\u0084\7\u0084\u076a\n\u0084\f\u0084\16\u0084\u076d"+
"\13\u0084\3\u0085\3\u0085\3\u0085\3\u0085\7\u0085\u0773\n\u0085\f\u0085"+
"\16\u0085\u0776\13\u0085\3\u0086\3\u0086\3\u0086\5\u0086\u077b\n\u0086"+
"\5\u0086\u077d\n\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088"+
"\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089"+
"\3\u008a\3\u008a\3\u008a\3\u008a\5\u008a\u0792\n\u008a\3\u008b\3\u008b"+
"\3\u008b\7\u008b\u0797\n\u008b\f\u008b\16\u008b\u079a\13\u008b\3\u008c"+
"\6\u008c\u079d\n\u008c\r\u008c\16\u008c\u079e\3\u008d\3\u008d\3\u008d"+
"\5\u008d\u07a4\n\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e"+
"\5\u008e\u07ac\n\u008e\3\u008e\5\u008e\u07af\n\u008e\3\u008f\3\u008f\3"+
"\u008f\3\u008f\3\u008f\7\u008f\u07b6\n\u008f\f\u008f\16\u008f\u07b9\13"+
"\u008f\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u07c1\n"+
"\u0090\3\u0090\5\u0090\u07c4\n\u0090\5\u0090\u07c6\n\u0090\3\u0090\5\u0090"+
"\u07c9\n\u0090\3\u0091\3\u0091\5\u0091\u07cd\n\u0091\3\u0091\5\u0091\u07d0"+
"\n\u0091\3\u0091\5\u0091\u07d3\n\u0091\3\u0091\3\u0091\3\u0092\3\u0092"+
"\3\u0092\3\u0092\7\u0092\u07db\n\u0092\f\u0092\16\u0092\u07de\13\u0092"+
"\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094\3\u0095\3\u0095\3\u0095"+
"\6\u0095\u07e9\n\u0095\r\u0095\16\u0095\u07ea\3\u0095\5\u0095\u07ee\n"+
"\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\6\u0095"+
"\u07f7\n\u0095\r\u0095\16\u0095\u07f8\3\u0095\5\u0095\u07fc\n\u0095\3"+
"\u0095\3\u0095\3\u0095\3\u0095\5\u0095\u0802\n\u0095\3\u0096\3\u0096\3"+
"\u0096\7\u0096\u0807\n\u0096\f\u0096\16\u0096\u080a\13\u0096\3\u0097\3"+
"\u0097\3\u0097\7\u0097\u080f\n\u0097\f\u0097\16\u0097\u0812\13\u0097\3"+
"\u0098\3\u0098\3\u0098\7\u0098\u0817\n\u0098\f\u0098\16\u0098\u081a\13"+
"\u0098\3\u0099\3\u0099\3\u0099\5\u0099\u081f\n\u0099\3\u009a\3\u009a\3"+
"\u009a\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u0828\n\u009a\3\u009a\3"+
"\u009a\3\u009a\3\u009a\5\u009a\u082e\n\u009a\3\u009a\3\u009a\5\u009a\u0832"+
"\n\u009a\3\u009a\3\u009a\5\u009a\u0836\n\u009a\5\u009a\u0838\n\u009a\7"+
"\u009a\u083a\n\u009a\f\u009a\16\u009a\u083d\13\u009a\3\u009b\3\u009b\3"+
"\u009b\3\u009b\3\u009b\5\u009b\u0844\n\u009b\3\u009b\3\u009b\3\u009b\3"+
"\u009b\5\u009b\u084a\n\u009b\3\u009b\3\u009b\5\u009b\u084e\n\u009b\3\u009b"+
"\3\u009b\5\u009b\u0852\n\u009b\5\u009b\u0854\n\u009b\7\u009b\u0856\n\u009b"+
"\f\u009b\16\u009b\u0859\13\u009b\3\u009b\5\u009b\u085c\n\u009b\3\u009b"+
"\3\u009b\3\u009b\5\u009b\u0861\n\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+
"\3\u009b\7\u009b\u0868\n\u009b\f\u009b\16\u009b\u086b\13\u009b\5\u009b"+
"\u086d\n\u009b\3\u009b\3\u009b\5\u009b\u0871\n\u009b\3\u009b\3\u009b\3"+
"\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u087b\n\u009b\3"+
"\u009b\3\u009b\5\u009b\u087f\n\u009b\5\u009b\u0881\n\u009b\3\u009c\3\u009c"+
"\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\7\u009d\u088a\n\u009d\f\u009d"+
"\16\u009d\u088d\13\u009d\5\u009d\u088f\n\u009d\3\u009e\3\u009e\3\u009e"+
"\7\u009e\u0894\n\u009e\f\u009e\16\u009e\u0897\13\u009e\3\u009f\3\u009f"+
"\3\u009f\7\u009f\u089c\n\u009f\f\u009f\16\u009f\u089f\13\u009f\3\u00a0"+
"\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u08a8\n\u00a0"+
"\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0"+
"\3\u00a0\7\u00a0\u08b4\n\u00a0\f\u00a0\16\u00a0\u08b7\13\u00a0\3\u00a0"+
"\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\7\u00a0\u08c1"+
"\n\u00a0\f\u00a0\16\u00a0\u08c4\13\u00a0\5\u00a0\u08c6\n\u00a0\3\u00a0"+
"\3\u00a0\5\u00a0\u08ca\n\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0"+
"\7\u00a0\u08d1\n\u00a0\f\u00a0\16\u00a0\u08d4\13\u00a0\3\u00a0\3\u00a0"+
"\5\u00a0\u08d8\n\u00a0\3\u00a0\5\u00a0\u08db\n\u00a0\3\u00a1\3\u00a1\3"+
"\u00a1\3\u00a2\3\u00a2\5\u00a2\u08e2\n\u00a2\3\u00a3\3\u00a3\3\u00a3\3"+
"\u00a3\7\u00a3\u08e8\n\u00a3\f\u00a3\16\u00a3\u08eb\13\u00a3\3\u00a4\3"+
"\u00a4\3\u00a4\5\u00a4\u08f0\n\u00a4\3\u00a5\3\u00a5\5\u00a5\u08f4\n\u00a5"+
"\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\5\u00a8"+
"\u08fe\n\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0905\n"+
"\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u090a\n\u00a8\3\u00a8\3\u00a8\5"+
"\u00a8\u090e\n\u00a8\3\u00a8\3\u00a8\3\u00a9\3\u00a9\5\u00a9\u0914\n\u00a9"+
"\3\u00a9\3\u00a9\3\u00a9\5\u00a9\u0919\n\u00a9\3\u00a9\3\u00a9\5\u00a9"+
"\u091d\n\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa\7\u00aa\u0923\n\u00aa\f"+
"\u00aa\16\u00aa\u0926\13\u00aa\5\u00aa\u0928\n\u00aa\3\u00aa\3\u00aa\5"+
"\u00aa\u092c\n\u00aa\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0931\n\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0939\n\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0942\n\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u094a\n\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0952\n\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u095a\n\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\7\u00ab\u0967\n\u00ab\f\u00ab\16\u00ab\u096a\13\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0973"+
"\n\u00ab\3\u00ab\3\u00ab\5\u00ab\u0977\n\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\5\u00ab\u097e\n\u00ab\3\u00ab\3\u00ab\5\u00ab\u0982\n"+
"\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\5\u00ab\u098e\n\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\7\u00ab\u09a8\n\u00ab\f\u00ab\16\u00ab\u09ab\13\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u09bb\n\u00ab\3\u00ab"+
"\3\u00ab\5\u00ab\u09bf\n\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u09c9\n\u00ab\3\u00ab\5\u00ab\u09cc\n"+
"\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u09d1\n\u00ab\3\u00ac\3\u00ac\3"+
"\u00ac\5\u00ac\u09d6\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u09da\n\u00ac\3\u00ac"+
"\3\u00ac\5\u00ac\u09de\n\u00ac\3\u00ad\3\u00ad\5\u00ad\u09e2\n\u00ad\3"+
"\u00ae\3\u00ae\3\u00ae\7\u00ae\u09e7\n\u00ae\f\u00ae\16\u00ae\u09ea\13"+
"\u00ae\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u09f1\n\u00af\3"+
"\u00af\3\u00af\5\u00af\u09f5\n\u00af\3\u00af\5\u00af\u09f8\n\u00af\3\u00b0"+
"\3\u00b0\3\u00b0\5\u00b0\u09fd\n\u00b0\3\u00b0\5\u00b0\u0a00\n\u00b0\3"+
"\u00b1\3\u00b1\3\u00b1\5\u00b1\u0a05\n\u00b1\3\u00b2\3\u00b2\3\u00b2\3"+
"\u00b2\5\u00b2\u0a0b\n\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3"+
"\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u0a17\n\u00b3\3\u00b4\5"+
"\u00b4\u0a1a\n\u00b4\3\u00b4\3\u00b4\3\u00b4\7\u00b4\u0a1f\n\u00b4\f\u00b4"+
"\16\u00b4\u0a22\13\u00b4\3\u00b5\5\u00b5\u0a25\n\u00b5\3\u00b5\3\u00b5"+
"\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b8\3\u00b8\7\u00b8"+
"\u0a31\n\u00b8\f\u00b8\16\u00b8\u0a34\13\u00b8\3\u00b9\3\u00b9\3\u00b9"+
"\3\u00b9\3\u00b9\5\u00b9\u0a3b\n\u00b9\3\u00b9\3\u00b9\3\u00ba\3\u00ba"+
"\3\u00ba\7\u00ba\u0a42\n\u00ba\f\u00ba\16\u00ba\u0a45\13\u00ba\3\u00bb"+
"\3\u00bb\3\u00bb\7\u00bb\u0a4a\n\u00bb\f\u00bb\16\u00bb\u0a4d\13\u00bb"+
"\3\u00bc\5\u00bc\u0a50\n\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0a55\n"+
"\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u0a5b\n\u00bd\3\u00bd\5"+
"\u00bd\u0a5e\n\u00bd\5\u00bd\u0a60\n\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be"+
"\3\u00be\3\u00be\3\u00be\5\u00be\u0a69\n\u00be\3\u00be\3\u00be\3\u00be"+
"\3\u00be\5\u00be\u0a6f\n\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\7\u00bf"+
"\u0a75\n\u00bf\f\u00bf\16\u00bf\u0a78\13\u00bf\3\u00bf\3\u00bf\3\u00c0"+
"\3\u00c0\3\u00c1\3\u00c1\5\u00c1\u0a80\n\u00c1\3\u00c2\3\u00c2\3\u00c2"+
"\3\u00c2\5\u00c2\u0a86\n\u00c2\3\u00c2\3\u00c2\5\u00c2\u0a8a\n\u00c2\3"+
"\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3\u0a93\n"+
"\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5"+
"\3\u00c5\3\u00c5\5\u00c5\u0a9f\n\u00c5\5\u00c5\u0aa1\n\u00c5\3\u00c5\3"+
"\u00c5\5\u00c5\u0aa5\n\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\5\u00c6\u0aab"+
"\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0ab0\n\u00c6\3\u00c6\5\u00c6"+
"\u0ab3\n\u00c6\3\u00c6\5\u00c6\u0ab6\n\u00c6\3\u00c7\3\u00c7\7\u00c7\u0aba"+
"\n\u00c7\f\u00c7\16\u00c7\u0abd\13\u00c7\3\u00c8\3\u00c8\5\u00c8\u0ac1"+
"\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0ac5\n\u00c8\3\u00c8\3\u00c8\5\u00c8"+
"\u0ac9\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0acd\n\u00c8\3\u00c8\3\u00c8\3"+
"\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\7\u00ca\u0ad8\n"+
"\u00ca\f\u00ca\16\u00ca\u0adb\13\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb"+
"\3\u00cb\5\u00cb\u0ae2\n\u00cb\5\u00cb\u0ae4\n\u00cb\3\u00cc\3\u00cc\3"+
"\u00cc\3\u00cc\3\u00cc\5\u00cc\u0aeb\n\u00cc\3\u00cd\3\u00cd\3\u00cd\3"+
"\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce\5\u00ce\u0af5\n\u00ce\3\u00ce\3"+
"\u00ce\3\u00ce\5\u00ce\u0afa\n\u00ce\3\u00ce\5\u00ce\u0afd\n\u00ce\3\u00ce"+
"\5\u00ce\u0b00\n\u00ce\3\u00ce\5\u00ce\u0b03\n\u00ce\3\u00cf\3\u00cf\3"+
"\u00cf\3\u00cf\3\u00cf\3\u00cf\5\u00cf\u0b0b\n\u00cf\3\u00d0\3\u00d0\7"+
"\u00d0\u0b0f\n\u00d0\f\u00d0\16\u00d0\u0b12\13\u00d0\3\u00d1\3\u00d1\5"+
"\u00d1\u0b16\n\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\7\u00d2\u0b1d"+
"\n\u00d2\f\u00d2\16\u00d2\u0b20\13\u00d2\3\u00d3\3\u00d3\3\u00d3\7\u00d3"+
"\u0b25\n\u00d3\f\u00d3\16\u00d3\u0b28\13\u00d3\3\u00d4\3\u00d4\3\u00d4"+
"\7\u00d4\u0b2d\n\u00d4\f\u00d4\16\u00d4\u0b30\13\u00d4\3\u00d5\3\u00d5"+
"\5\u00d5\u0b34\n\u00d5\3\u00d6\3\u00d6\5\u00d6\u0b38\n\u00d6\3\u00d7\3"+
"\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0b3f\n\u00d7\3\u00d7\5\u00d7\u0b42"+
"\n\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\5\u00d8\u0b49\n\u00d8"+
"\3\u00d8\5\u00d8\u0b4c\n\u00d8\3\u00d9\3\u00d9\3\u00d9\7\u00d9\u0b51\n"+
"\u00d9\f\u00d9\16\u00d9\u0b54\13\u00d9\3\u00da\3\u00da\3\u00da\7\u00da"+
"\u0b59\n\u00da\f\u00da\16\u00da\u0b5c\13\u00da\3\u00db\3\u00db\3\u00db"+
"\3\u00db\3\u00db\3\u00db\3\u00db\3\u00db\3\u00db\3\u00db\5\u00db\u0b68"+
"\n\u00db\3\u00dc\3\u00dc\5\u00dc\u0b6c\n\u00dc\3\u00dd\3\u00dd\3\u00dd"+
"\3\u00dd\3\u00dd\3\u00dd\5\u00dd\u0b74\n\u00dd\3\u00de\3\u00de\3\u00df"+
"\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\5\u00e0\u0b7f\n\u00e0"+
"\3\u00e1\3\u00e1\3\u00e1\5\u00e1\u0b84\n\u00e1\3\u00e1\3\u00e1\3\u00e1"+
"\3\u00e1\5\u00e1\u0b8a\n\u00e1\3\u00e2\3\u00e2\3\u00e2\5\u00e2\u0b8f\n"+
"\u00e2\3\u00e2\3\u00e2\3\u00e3\3\u00e3\3\u00e3\5\u00e3\u0b96\n\u00e3\3"+
"\u00e3\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\7\u00e4\u0b9e\n\u00e4\f"+
"\u00e4\16\u00e4\u0ba1\13\u00e4\3\u00e4\3\u00e4\3\u00e5\3\u00e5\3\u00e5"+
"\5\u00e5\u0ba8\n\u00e5\3\u00e6\3\u00e6\3\u00e6\7\u00e6\u0bad\n\u00e6\f"+
"\u00e6\16\u00e6\u0bb0\13\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7"+
"\5\u00e7\u0bb7\n\u00e7\3\u00e7\3\u00e7\3\u00e7\5\u00e7\u0bbc\n\u00e7\3"+
"\u00e7\3\u00e7\5\u00e7\u0bc0\n\u00e7\3\u00e7\5\u00e7\u0bc3\n\u00e7\3\u00e8"+
"\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u0bc9\n\u00e8\7\u00e8\u0bcb\n\u00e8\f"+
"\u00e8\16\u00e8\u0bce\13\u00e8\3\u00e9\3\u00e9\5\u00e9\u0bd2\n\u00e9\3"+
"\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
"\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
"\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
"\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
"\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
"\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\5\u00ea\u0c08"+
"\n\u00ea\3\u00eb\3\u00eb\3\u00eb\5\u00eb\u0c0d\n\u00eb\3\u00ec\3\u00ec"+
"\5\u00ec\u0c11\n\u00ec\3\u00ed\3\u00ed\5\u00ed\u0c15\n\u00ed\3\u00ed\5"+
"\u00ed\u0c18\n\u00ed\3\u00ed\5\u00ed\u0c1b\n\u00ed\3\u00ed\5\u00ed\u0c1e"+
"\n\u00ed\3\u00ed\5\u00ed\u0c21\n\u00ed\3\u00ed\5\u00ed\u0c24\n\u00ed\3"+
"\u00ed\5\u00ed\u0c27\n\u00ed\3\u00ed\5\u00ed\u0c2a\n\u00ed\3\u00ed\3\u00ed"+
"\5\u00ed\u0c2e\n\u00ed\3\u00ed\5\u00ed\u0c31\n\u00ed\3\u00ed\5\u00ed\u0c34"+
"\n\u00ed\3\u00ed\5\u00ed\u0c37\n\u00ed\3\u00ed\5\u00ed\u0c3a\n\u00ed\3"+
"\u00ed\5\u00ed\u0c3d\n\u00ed\3\u00ed\5\u00ed\u0c40\n\u00ed\3\u00ed\3\u00ed"+
"\5\u00ed\u0c44\n\u00ed\3\u00ed\5\u00ed\u0c47\n\u00ed\3\u00ed\5\u00ed\u0c4a"+
"\n\u00ed\3\u00ed\5\u00ed\u0c4d\n\u00ed\3\u00ed\5\u00ed\u0c50\n\u00ed\3"+
"\u00ed\5\u00ed\u0c53\n\u00ed\3\u00ed\3\u00ed\5\u00ed\u0c57\n\u00ed\3\u00ed"+
"\5\u00ed\u0c5a\n\u00ed\3\u00ed\5\u00ed\u0c5d\n\u00ed\3\u00ed\5\u00ed\u0c60"+
"\n\u00ed\3\u00ed\5\u00ed\u0c63\n\u00ed\3\u00ed\3\u00ed\5\u00ed\u0c67\n"+
"\u00ed\3\u00ed\5\u00ed\u0c6a\n\u00ed\3\u00ed\5\u00ed\u0c6d\n\u00ed\3\u00ed"+
"\5\u00ed\u0c70\n\u00ed\3\u00ed\3\u00ed\5\u00ed\u0c74\n\u00ed\3\u00ed\5"+
"\u00ed\u0c77\n\u00ed\3\u00ed\5\u00ed\u0c7a\n\u00ed\3\u00ed\3\u00ed\5\u00ed"+
"\u0c7e\n\u00ed\3\u00ed\5\u00ed\u0c81\n\u00ed\3\u00ed\3\u00ed\5\u00ed\u0c85"+
"\n\u00ed\3\u00ed\5\u00ed\u0c88\n\u00ed\3\u00ee\3\u00ee\3\u00ee\5\u00ee"+
"\u0c8d\n\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\5\u00ef\u0c94\n"+
"\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0\5\u00f0\u0c9b\n\u00f0\3"+
"\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1\5\u00f1\u0ca2\n\u00f1\3\u00f1\3"+
"\u00f1\3\u00f2\3\u00f2\3\u00f2\5\u00f2\u0ca9\n\u00f2\3\u00f2\3\u00f2\3"+
"\u00f3\3\u00f3\3\u00f3\5\u00f3\u0cb0\n\u00f3\3\u00f3\3\u00f3\3\u00f4\3"+
"\u00f4\3\u00f4\5\u00f4\u0cb7\n\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3"+
"\u00f5\5\u00f5\u0cbe\n\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6\3\u00f6\5"+
"\u00f6\u0cc5\n\u00f6\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3"+
"\u00f8\5\u00f8\u0cce\n\u00f8\3\u00f8\3\u00f8\5\u00f8\u0cd2\n\u00f8\5\u00f8"+
"\u0cd4\n\u00f8\3\u00f9\5\u00f9\u0cd7\n\u00f9\3\u00f9\3\u00f9\3\u00f9\7"+
"\u00f9\u0cdc\n\u00f9\f\u00f9\16\u00f9\u0cdf\13\u00f9\3\u00fa\3\u00fa\3"+
"\u00fa\3\u00fa\3\u00fa\5\u00fa\u0ce6\n\u00fa\3\u00fb\3\u00fb\5\u00fb\u0cea"+
"\n\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\5\u00fc\u0cf0\n\u00fc\3\u00fd"+
"\3\u00fd\3\u00fd\5\u00fd\u0cf5\n\u00fd\3\u00fe\3\u00fe\3\u00fe\3\u00fe"+
"\3\u00ff\3\u00ff\5\u00ff\u0cfd\n\u00ff\3\u00ff\3\u00ff\3\u0100\3\u0100"+
"\3\u0100\7\u0100\u0d04\n\u0100\f\u0100\16\u0100\u0d07\13\u0100\3\u0100"+
"\5\u0100\u0d0a\n\u0100\3\u0101\3\u0101\3\u0101\7\u0101\u0d0f\n\u0101\f"+
"\u0101\16\u0101\u0d12\13\u0101\3\u0101\5\u0101\u0d15\n\u0101\3\u0102\3"+
"\u0102\5\u0102\u0d19\n\u0102\3\u0102\3\u0102\3\u0102\3\u0102\2\2\u0103"+
"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH"+
"JLNPRTVXZ\\^`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\u01f8\u01fa\u01fc\u01fe\u0200\u0202\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\2\u0ecd\2\u0208"+
"\3\2\2\2\4\u020e\3\2\2\2\6\u0211\3\2\2\2\b\u0214\3\2\2\2\n\u0230\3\2\2"+
"\2\f\u023e\3\2\2\2\16\u0245\3\2\2\2\20\u0249\3\2\2\2\22\u024f\3\2\2\2"+
"\24\u0259\3\2\2\2\26\u0261\3\2\2\2\30\u026a\3\2\2\2\32\u026c\3\2\2\2\34"+
"\u027d\3\2\2\2\36\u0292\3\2\2\2 \u0297\3\2\2\2\"\u02c0\3\2\2\2$\u02d5"+
"\3\2\2\2&\u02dc\3\2\2\2(\u02e0\3\2\2\2*\u02ec\3\2\2\2,\u0304\3\2\2\2."+
"\u0306\3\2\2\2\60\u0311\3\2\2\2\62\u0322\3\2\2\2\64\u032c\3\2\2\2\66\u0338"+
"\3\2\2\28\u033b\3\2\2\2:\u034e\3\2\2\2<\u0374\3\2\2\2>\u0381\3\2\2\2@"+
"\u038c\3\2\2\2B\u0393\3\2\2\2D\u0398\3\2\2\2F\u039e\3\2\2\2H\u03a1\3\2"+
"\2\2J\u03ae\3\2\2\2L\u03b0\3\2\2\2N\u03b7\3\2\2\2P\u03d6\3\2\2\2R\u03da"+
"\3\2\2\2T\u03e6\3\2\2\2V\u03f4\3\2\2\2X\u0400\3\2\2\2Z\u040b\3\2\2\2\\"+
"\u0415\3\2\2\2^\u041d\3\2\2\2`\u0430\3\2\2\2b\u0438\3\2\2\2d\u043d\3\2"+
"\2\2f\u044f\3\2\2\2h\u0451\3\2\2\2j\u0457\3\2\2\2l\u046a\3\2\2\2n\u0476"+
"\3\2\2\2p\u0479\3\2\2\2r\u0480\3\2\2\2t\u0488\3\2\2\2v\u04aa\3\2\2\2x"+
"\u04ac\3\2\2\2z\u04b0\3\2\2\2|\u04ba\3\2\2\2~\u04bf\3\2\2\2\u0080\u04c6"+
"\3\2\2\2\u0082\u04c9\3\2\2\2\u0084\u04d2\3\2\2\2\u0086\u04d6\3\2\2\2\u0088"+
"\u04e3\3\2\2\2\u008a\u04e5\3\2\2\2\u008c\u04e9\3\2\2\2\u008e\u04fe\3\2"+
"\2\2\u0090\u0500\3\2\2\2\u0092\u0508\3\2\2\2\u0094\u0516\3\2\2\2\u0096"+
"\u0518\3\2\2\2\u0098\u056b\3\2\2\2\u009a\u056d\3\2\2\2\u009c\u057d\3\2"+
"\2\2\u009e\u057f\3\2\2\2\u00a0\u0586\3\2\2\2\u00a2\u0596\3\2\2\2\u00a4"+
"\u059a\3\2\2\2\u00a6\u05a2\3\2\2\2\u00a8\u05ae\3\2\2\2\u00aa\u05b4\3\2"+
"\2\2\u00ac\u05b7\3\2\2\2\u00ae\u05c1\3\2\2\2\u00b0\u05c3\3\2\2\2\u00b2"+
"\u05c9\3\2\2\2\u00b4\u05d4\3\2\2\2\u00b6\u05dc\3\2\2\2\u00b8\u05e5\3\2"+
"\2\2\u00ba\u05e8\3\2\2\2\u00bc\u05f8\3\2\2\2\u00be\u05ff\3\2\2\2\u00c0"+
"\u0608\3\2\2\2\u00c2\u060c\3\2\2\2\u00c4\u0611\3\2\2\2\u00c6\u0618\3\2"+
"\2\2\u00c8\u0623\3\2\2\2\u00ca\u0625\3\2\2\2\u00cc\u062f\3\2\2\2\u00ce"+
"\u0632\3\2\2\2\u00d0\u063d\3\2\2\2\u00d2\u064e\3\2\2\2\u00d4\u0657\3\2"+
"\2\2\u00d6\u0662\3\2\2\2\u00d8\u0673\3\2\2\2\u00da\u0692\3\2\2\2\u00dc"+
"\u0694\3\2\2\2\u00de\u069a\3\2\2\2\u00e0\u06a0\3\2\2\2\u00e2\u06a9\3\2"+
"\2\2\u00e4\u06b4\3\2\2\2\u00e6\u06b6\3\2\2\2\u00e8\u06c2\3\2\2\2\u00ea"+
"\u06d1\3\2\2\2\u00ec\u06e0\3\2\2\2\u00ee\u06e2\3\2\2\2\u00f0\u06ea\3\2"+
"\2\2\u00f2\u06ef\3\2\2\2\u00f4\u06f2\3\2\2\2\u00f6\u071b\3\2\2\2\u00f8"+
"\u0726\3\2\2\2\u00fa\u072f\3\2\2\2\u00fc\u073b\3\2\2\2\u00fe\u0743\3\2"+
"\2\2\u0100\u0747\3\2\2\2\u0102\u074c\3\2\2\2\u0104\u074f\3\2\2\2\u0106"+
"\u0764\3\2\2\2\u0108\u076e\3\2\2\2\u010a\u0777\3\2\2\2\u010c\u077e\3\2"+
"\2\2\u010e\u0781\3\2\2\2\u0110\u0786\3\2\2\2\u0112\u078d\3\2\2\2\u0114"+
"\u0793\3\2\2\2\u0116\u079c\3\2\2\2\u0118\u07a3\3\2\2\2\u011a\u07a5\3\2"+
"\2\2\u011c\u07b0\3\2\2\2\u011e\u07bc\3\2\2\2\u0120\u07ca\3\2\2\2\u0122"+
"\u07d6\3\2\2\2\u0124\u07df\3\2\2\2\u0126\u07e3\3\2\2\2\u0128\u0801\3\2"+
"\2\2\u012a\u0803\3\2\2\2\u012c\u080b\3\2\2\2\u012e\u0813\3\2\2\2\u0130"+
"\u081e\3\2\2\2\u0132\u0820\3\2\2\2\u0134\u083e\3\2\2\2\u0136\u0882\3\2"+
"\2\2\u0138\u0884\3\2\2\2\u013a\u0890\3\2\2\2\u013c\u0898\3\2\2\2\u013e"+
"\u08da\3\2\2\2\u0140\u08dc\3\2\2\2\u0142\u08df\3\2\2\2\u0144\u08e3\3\2"+
"\2\2\u0146\u08ec\3\2\2\2\u0148\u08f1\3\2\2\2\u014a\u08f5\3\2\2\2\u014c"+
"\u08f7\3\2\2\2\u014e\u08fa\3\2\2\2\u0150\u0911\3\2\2\2\u0152\u091e\3\2"+
"\2\2\u0154\u09d0\3\2\2\2\u0156\u09d5\3\2\2\2\u0158\u09e1\3\2\2\2\u015a"+
"\u09e3\3\2\2\2\u015c\u09f0\3\2\2\2\u015e\u09f9\3\2\2\2\u0160\u0a04\3\2"+
"\2\2\u0162\u0a0a\3\2\2\2\u0164\u0a16\3\2\2\2\u0166\u0a19\3\2\2\2\u0168"+
"\u0a24\3\2\2\2\u016a\u0a28\3\2\2\2\u016c\u0a2c\3\2\2\2\u016e\u0a2e\3\2"+
"\2\2\u0170\u0a3a\3\2\2\2\u0172\u0a3e\3\2\2\2\u0174\u0a46\3\2\2\2\u0176"+
"\u0a4f\3\2\2\2\u0178\u0a5f\3\2\2\2\u017a\u0a68\3\2\2\2\u017c\u0a70\3\2"+
"\2\2\u017e\u0a7b\3\2\2\2\u0180\u0a7f\3\2\2\2\u0182\u0a81\3\2\2\2\u0184"+
"\u0a8d\3\2\2\2\u0186\u0a96\3\2\2\2\u0188\u0a9a\3\2\2\2\u018a\u0aaa\3\2"+
"\2\2\u018c\u0ab7\3\2\2\2\u018e\u0abe\3\2\2\2\u0190\u0ad0\3\2\2\2\u0192"+
"\u0ad4\3\2\2\2\u0194\u0ae3\3\2\2\2\u0196\u0ae5\3\2\2\2\u0198\u0aec\3\2"+
"\2\2\u019a\u0af4\3\2\2\2\u019c\u0b04\3\2\2\2\u019e\u0b0c\3\2\2\2\u01a0"+
"\u0b13\3\2\2\2\u01a2\u0b19\3\2\2\2\u01a4\u0b21\3\2\2\2\u01a6\u0b29\3\2"+
"\2\2\u01a8\u0b33\3\2\2\2\u01aa\u0b37\3\2\2\2\u01ac\u0b39\3\2\2\2\u01ae"+
"\u0b43\3\2\2\2\u01b0\u0b4d\3\2\2\2\u01b2\u0b55\3\2\2\2\u01b4\u0b67\3\2"+
"\2\2\u01b6\u0b6b\3\2\2\2\u01b8\u0b6d\3\2\2\2\u01ba\u0b75\3\2\2\2\u01bc"+
"\u0b77\3\2\2\2\u01be\u0b79\3\2\2\2\u01c0\u0b83\3\2\2\2\u01c2\u0b8e\3\2"+
"\2\2\u01c4\u0b95\3\2\2\2\u01c6\u0b99\3\2\2\2\u01c8\u0ba7\3\2\2\2\u01ca"+
"\u0ba9\3\2\2\2\u01cc\u0bb1\3\2\2\2\u01ce\u0bc4\3\2\2\2\u01d0\u0bd1\3\2"+
"\2\2\u01d2\u0c07\3\2\2\2\u01d4\u0c0c\3\2\2\2\u01d6\u0c10\3\2\2\2\u01d8"+
"\u0c87\3\2\2\2\u01da\u0c8c\3\2\2\2\u01dc\u0c93\3\2\2\2\u01de\u0c9a\3\2"+
"\2\2\u01e0\u0ca1\3\2\2\2\u01e2\u0ca8\3\2\2\2\u01e4\u0caf\3\2\2\2\u01e6"+
"\u0cb6\3\2\2\2\u01e8\u0cbd\3\2\2\2\u01ea\u0cc4\3\2\2\2\u01ec\u0cc8\3\2"+
"\2\2\u01ee\u0cca\3\2\2\2\u01f0\u0cd6\3\2\2\2\u01f2\u0ce5\3\2\2\2\u01f4"+
"\u0ce9\3\2\2\2\u01f6\u0cef\3\2\2\2\u01f8\u0cf4\3\2\2\2\u01fa\u0cf6\3\2"+
"\2\2\u01fc\u0cfa\3\2\2\2\u01fe\u0d00\3\2\2\2\u0200\u0d0b\3\2\2\2\u0202"+
"\u0d18\3\2\2\2\u0204\u0207\5\22\n\2\u0205\u0207\5\b\5\2\u0206\u0204\3"+
"\2\2\2\u0206\u0205\3\2\2\2\u0207\u020a\3\2\2\2\u0208\u0206\3\2\2\2\u0208"+
"\u0209\3\2\2\2\u0209\u020b\3\2\2\2\u020a\u0208\3\2\2\2\u020b\u020c\5\34"+
"\17\2\u020c\u020d\7\2\2\3\u020d\3\3\2\2\2\u020e\u020f\5\u01ca\u00e6\2"+
"\u020f\u0210\7\2\2\3\u0210\5\3\2\2\2\u0211\u0212\5\u01f8\u00fd\2\u0212"+
"\u0213\7\2\2\3\u0213\7\3\2\2\2\u0214\u0216\7\177\2\2\u0215\u0217\5\u01a2"+
"\u00d2\2\u0216\u0215\3\2\2\2\u0216\u0217\3\2\2\2\u0217\u021a\3\2\2\2\u0218"+
"\u0219\7\u0094\2\2\u0219\u021b\7\u0095\2\2\u021a\u0218\3\2\2\2\u021a\u021b"+
"\3\2\2\2\u021b\u021d\3\2\2\2\u021c\u021e\5\u0198\u00cd\2\u021d\u021c\3"+
"\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220\3\2\2\2\u021f\u0221\5\n\6\2\u0220"+
"\u021f\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0228\7\u00c5"+
"\2\2\u0223\u0225\7\u0092\2\2\u0224\u0226\5\u00b4[\2\u0225\u0224\3\2\2"+
"\2\u0225\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0229\7\u0093\2\2\u0228"+
"\u0223\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022c\3\2\2\2\u022a\u022b\7\u00c5"+
"\2\2\u022b\u022d\7z\2\2\u022c\u022a\3\2\2\2\u022c\u022d\3\2\2\2\u022d"+
"\u022e\3\2\2\2\u022e\u022f\5\f\7\2\u022f\t\3\2\2\2\u0230\u0231\7\u00c5"+
"\2\2\u0231\u0232\7\u0098\2\2\u0232\13\3\2\2\2\u0233\u0235\7\u0096\2\2"+
"\u0234\u0236\5\16\b\2\u0235\u0234\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237"+
"\3\2\2\2\u0237\u0238\5\u0126\u0094\2\u0238\u0239\7\u0097\2\2\u0239\u023f"+
"\3\2\2\2\u023a\u023b\7\u0094\2\2\u023b\u023c\5\u01f6\u00fc\2\u023c\u023d"+
"\7\u0095\2\2\u023d\u023f\3\2\2\2\u023e\u0233\3\2\2\2\u023e\u023a\3\2\2"+
"\2\u023f\r\3\2\2\2\u0240\u0246\7\u00c5\2\2\u0241\u0242\7\u0092\2\2\u0242"+
"\u0243\5\u00b4[\2\u0243\u0244\7\u0093\2\2\u0244\u0246\3\2\2\2\u0245\u0240"+
"\3\2\2\2\u0245\u0241\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u0248\t\2\2\2\u0248"+
"\17\3\2\2\2\u0249\u024a\7\u00bd\2\2\u024a\u024b\7\u00c5\2\2\u024b\u024c"+
"\7\u0092\2\2\u024c\u024d\7\u00c5\2\2\u024d\u024e\7\u0093\2\2\u024e\21"+
"\3\2\2\2\u024f\u0250\7\u00bd\2\2\u0250\u0257\5\u01a2\u00d2\2\u0251\u0254"+
"\7\u0092\2\2\u0252\u0255\5\24\13\2\u0253\u0255\5\30\r\2\u0254\u0252\3"+
"\2\2\2\u0254\u0253\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0256\3\2\2\2\u0256"+
"\u0258\7\u0093\2\2\u0257\u0251\3\2\2\2\u0257\u0258\3\2\2\2\u0258\23\3"+
"\2\2\2\u0259\u025e\5\26\f\2\u025a\u025b\7\u0099\2\2\u025b\u025d\5\26\f"+
"\2\u025c\u025a\3\2\2\2\u025d\u0260\3\2\2\2\u025e\u025c\3\2\2\2\u025e\u025f"+
"\3\2\2\2\u025f\25\3\2\2\2\u0260\u025e\3\2\2\2\u0261\u0262\5\u01d2\u00ea"+
"\2\u0262\u0263\7\u008f\2\2\u0263\u0264\5\30\r\2\u0264\27\3\2\2\2\u0265"+
"\u026b\5\22\n\2\u0266\u026b\5\32\16\2\u0267\u026b\5\u01f2\u00fa\2\u0268"+
"\u026b\7\u00c5\2\2\u0269\u026b\5\u01a2\u00d2\2\u026a\u0265\3\2\2\2\u026a"+
"\u0266\3\2\2\2\u026a\u0267\3\2\2\2\u026a\u0268\3\2\2\2\u026a\u0269\3\2"+
"\2\2\u026b\31\3\2\2\2\u026c\u0275\7\u0096\2\2\u026d\u0272\5\30\r\2\u026e"+
"\u026f\7\u0099\2\2\u026f\u0271\5\30\r\2\u0270\u026e\3\2\2\2\u0271\u0274"+
"\3\2\2\2\u0272\u0270\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u0276\3\2\2\2\u0274"+
"\u0272\3\2\2\2\u0275\u026d\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0278\3\2"+
"\2\2\u0277\u0279\7\u0099\2\2\u0278\u0277\3\2\2\2\u0278\u0279\3\2\2\2\u0279"+
"\u027a\3\2\2\2\u027a\u027b\7\u0097\2\2\u027b\33\3\2\2\2\u027c\u027e\5"+
"\36\20\2\u027d\u027c\3\2\2\2\u027d\u027e\3\2\2\2\u027e\u028d\3\2\2\2\u027f"+
"\u028e\5 \21\2\u0280\u028e\5N(\2\u0281\u028e\5R*\2\u0282\u028e\5X-\2\u0283"+
"\u028e\5Z.\2\u0284\u028e\5h\65\2\u0285\u028e\5\u0090I\2\u0286\u028e\5"+
"\u0092J\2\u0287\u028e\5\"\22\2\u0288\u028e\5&\24\2\u0289\u028e\5r:\2\u028a"+
"\u028e\5l\67\2\u028b\u028e\5n8\2\u028c\u028e\5p9\2\u028d\u027f\3\2\2\2"+
"\u028d\u0280\3\2\2\2\u028d\u0281\3\2\2\2\u028d\u0282\3\2\2\2\u028d\u0283"+
"\3\2\2\2\u028d\u0284\3\2\2\2\u028d\u0285\3\2\2\2\u028d\u0286\3\2\2\2\u028d"+
"\u0287\3\2\2\2\u028d\u0288\3\2\2\2\u028d\u0289\3\2\2\2\u028d\u028a\3\2"+
"\2\2\u028d\u028b\3\2\2\2\u028d\u028c\3\2\2\2\u028e\u0290\3\2\2\2\u028f"+
"\u0291\5\u00d2j\2\u0290\u028f\3\2\2\2\u0290\u0291\3\2\2\2\u0291\35\3\2"+
"\2\2\u0292\u0293\7\u0082\2\2\u0293\u0294\7\u00c5\2\2\u0294\37\3\2\2\2"+
"\u0295\u0296\7\65\2\2\u0296\u0298\5\u00b0Y\2\u0297\u0295\3\2\2\2\u0297"+
"\u0298\3\2\2\2\u0298\u029b\3\2\2\2\u0299\u029a\7\64\2\2\u029a\u029c\5"+
"\u00b2Z\2\u029b\u0299\3\2\2\2\u029b\u029c\3\2\2\2\u029c\u029d\3\2\2\2"+
"\u029d\u029e\7\32\2\2\u029e\u02a1\5\u00c4c\2\u029f\u02a0\7 \2\2\u02a0"+
"\u02a2\5\u00b6\\\2\u02a1\u029f\3\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a4"+
"\3\2\2\2\u02a3\u02a5\5\u0104\u0083\2\u02a4\u02a3\3\2\2\2\u02a4\u02a5\3"+
"\2\2\2\u02a5\u02a8\3\2\2\2\u02a6\u02a7\7\17\2\2\u02a7\u02a9\5\u00c2b\2"+
"\u02a8\u02a6\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\u02ad\3\2\2\2\u02aa\u02ab"+
"\7*\2\2\u02ab\u02ac\7)\2\2\u02ac\u02ae\5\u00e2r\2\u02ad\u02aa\3\2\2\2"+
"\u02ad\u02ae\3\2\2\2\u02ae\u02b1\3\2\2\2\u02af\u02b0\7+\2\2\u02b0\u02b2"+
"\5\u00f2z\2\u02b1\u02af\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b5\3\2\2"+
"\2\u02b3\u02b4\7\60\2\2\u02b4\u02b6\5\u00f4{\2\u02b5\u02b3\3\2\2\2\u02b5"+
"\u02b6\3\2\2\2\u02b6\u02ba\3\2\2\2\u02b7\u02b8\7\67\2\2\u02b8\u02b9\7"+
")\2\2\u02b9\u02bb\5\u00eex\2\u02ba\u02b7\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb"+
"\u02be\3\2\2\2\u02bc\u02bd\7p\2\2\u02bd\u02bf\5\u00fa~\2\u02be\u02bc\3"+
"\2\2\2\u02be\u02bf\3\2\2\2\u02bf!\3\2\2\2\u02c0\u02c1\7\'\2\2\u02c1\u02d1"+
"\5$\23\2\u02c2\u02d2\5D#\2\u02c3\u02cc\5:\36\2\u02c4\u02c6\5> \2\u02c5"+
"\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c7\u02c8\3\2"+
"\2\2\u02c8\u02ca\3\2\2\2\u02c9\u02cb\5B\"\2\u02ca\u02c9\3\2\2\2\u02ca"+
"\u02cb\3\2\2\2\u02cb\u02cd\3\2\2\2\u02cc\u02c5\3\2\2\2\u02cc\u02cd\3\2"+
"\2\2\u02cd\u02d2\3\2\2\2\u02ce\u02d2\5F$\2\u02cf\u02d2\5<\37\2\u02d0\u02d2"+
"\5*\26\2\u02d1\u02c2\3\2\2\2\u02d1\u02c3\3\2\2\2\u02d1\u02ce\3\2\2\2\u02d1"+
"\u02cf\3\2\2\2\u02d1\u02d0\3\2\2\2\u02d2#\3\2\2\2\u02d3\u02d6\5\u018a"+
"\u00c6\2\u02d4\u02d6\5\u00d4k\2\u02d5\u02d3\3\2\2\2\u02d5\u02d4\3\2\2"+
"\2\u02d6\u02da\3\2\2\2\u02d7\u02d8\7\20\2\2\u02d8\u02db\5\u01d0\u00e9"+
"\2\u02d9\u02db\5\u01d0\u00e9\2\u02da\u02d7\3\2\2\2\u02da\u02d9\3\2\2\2"+
"\u02da\u02db\3\2\2\2\u02db%\3\2\2\2\u02dc\u02dd\7r\2\2\u02dd\u02de\7;"+
"\2\2\u02de\u02df\5(\25\2\u02df\'\3\2\2\2\u02e0\u02e4\5\u01a2\u00d2\2\u02e1"+
"\u02e2\7\20\2\2\u02e2\u02e5\5\u01d0\u00e9\2\u02e3\u02e5\5\u01d0\u00e9"+
"\2\u02e4\u02e1\3\2\2\2\u02e4\u02e3\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5\u02e6"+
"\3\2\2\2\u02e6\u02e7\7R\2\2\u02e7\u02ea\5H%\2\u02e8\u02e9\7\17\2\2\u02e9"+
"\u02eb\5\u00c2b\2\u02ea\u02e8\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb)\3\2\2"+
"\2\u02ec\u02ee\7}\2\2\u02ed\u02ef\7\65\2\2\u02ee\u02ed\3\2\2\2\u02ee\u02ef"+
"\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0\u02f4\7\u00c5\2\2\u02f1\u02f2\7\20"+
"\2\2\u02f2\u02f5\5\u01d0\u00e9\2\u02f3\u02f5\5\u01d0\u00e9\2\u02f4\u02f1"+
"\3\2\2\2\u02f4\u02f3\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u0300\3\2\2\2\u02f6"+
"\u0301\5\62\32\2\u02f7\u02f8\7\17\2\2\u02f8\u02fa\5\u00c2b\2\u02f9\u02f7"+
"\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fc\3\2\2\2\u02fb\u02fd\5,\27\2\u02fc"+
"\u02fb\3\2\2\2\u02fd\u02fe\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2"+
"\2\2\u02ff\u0301\3\2\2\2\u0300\u02f6\3\2\2\2\u0300\u02f9\3\2\2\2\u0301"+
"+\3\2\2\2\u0302\u0305\5.\30\2\u0303\u0305\5\64\33\2\u0304\u0302\3\2\2"+
"\2\u0304\u0303\3\2\2\2\u0305-\3\2\2\2\u0306\u0307\7\35\2\2\u0307\u030a"+
"\7~\2\2\u0308\u0309\7\13\2\2\u0309\u030b\5\u0126\u0094\2\u030a\u0308\3"+
"\2\2\2\u030a\u030b\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u030e\5\60\31\2\u030d"+
"\u030c\3\2\2\2\u030e\u030f\3\2\2\2\u030f\u030d\3\2\2\2\u030f\u0310\3\2"+
"\2\2\u0310/\3\2\2\2\u0311\u0320\7\36\2\2\u0312\u0313\7r\2\2\u0313\u0314"+
"\7R\2\2\u0314\u0315\5H%\2\u0315\u0318\3\2\2\2\u0316\u0317\7\17\2\2\u0317"+
"\u0319\5\u00c2b\2\u0318\u0316\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u0321"+
"\3\2\2\2\u031a\u031d\7P\2\2\u031b\u031c\7\17\2\2\u031c\u031e\5\u00c2b"+
"\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0321\3\2\2\2\u031f\u0321"+
"\58\35\2\u0320\u0312\3\2\2\2\u0320\u031a\3\2\2\2\u0320\u031f\3\2\2\2\u0321"+
"\61\3\2\2\2\u0322\u0327\7\64\2\2\u0323\u0324\7\u0092\2\2\u0324\u0325\5"+
"\u00b4[\2\u0325\u0326\7\u0093\2\2\u0326\u0328\3\2\2\2\u0327\u0323\3\2"+
"\2\2\u0327\u0328\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u032a\7\32\2\2\u032a"+
"\u032b\5\u00c6d\2\u032b\63\3\2\2\2\u032c\u032d\7\35\2\2\u032d\u032e\7"+
"\f\2\2\u032e\u0331\7~\2\2\u032f\u0330\7\13\2\2\u0330\u0332\5\u0126\u0094"+
"\2\u0331\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332\u0334\3\2\2\2\u0333\u0335"+
"\5\66\34\2\u0334\u0333\3\2\2\2\u0335\u0336\3\2\2\2\u0336\u0334\3\2\2\2"+
"\u0336\u0337\3\2\2\2\u0337\65\3\2\2\2\u0338\u0339\7\36\2\2\u0339\u033a"+
"\58\35\2\u033a\67\3\2\2\2\u033b\u033e\7\64\2\2\u033c\u033d\7\65\2\2\u033d"+
"\u033f\5\u01a2\u00d2\2\u033e\u033c\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u0344"+
"\3\2\2\2\u0340\u0341\7\u0092\2\2\u0341\u0342\5\u00b4[\2\u0342\u0343\7"+
"\u0093\2\2\u0343\u0345\3\2\2\2\u0344\u0340\3\2\2\2\u0344\u0345\3\2\2\2"+
"\u0345\u0346\3\2\2\2\u0346\u0347\7\32\2\2\u0347\u034a\5\u00c6d\2\u0348"+
"\u0349\7\17\2\2\u0349\u034b\5\u00c2b\2\u034a\u0348\3\2\2\2\u034a\u034b"+
"\3\2\2\2\u034b9\3\2\2\2\u034c\u034d\7\64\2\2\u034d\u034f\5\u00b2Z\2\u034e"+
"\u034c\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0355\7\32"+
"\2\2\u0351\u0353\7\13\2\2\u0352\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353"+
"\u0354\3\2\2\2\u0354\u0356\7P\2\2\u0355\u0352\3\2\2\2\u0355\u0356\3\2"+
"\2\2\u0356\u0358\3\2\2\2\u0357\u0359\7,\2\2\u0358\u0357\3\2\2\2\u0358"+
"\u0359\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u035c\5\u00c6d\2\u035b\u035d"+
"\5L\'\2\u035c\u035b\3\2\2\2\u035c\u035d\3\2\2\2\u035d\u0360\3\2\2\2\u035e"+
"\u035f\7\17\2\2\u035f\u0361\5\u00c2b\2\u0360\u035e\3\2\2\2\u0360\u0361"+
"\3\2\2\2\u0361\u0365\3\2\2\2\u0362\u0363\7*\2\2\u0363\u0364\7)\2\2\u0364"+
"\u0366\5\u00e2r\2\u0365\u0362\3\2\2\2\u0365\u0366\3\2\2\2\u0366\u0369"+
"\3\2\2\2\u0367\u0368\7+\2\2\u0368\u036a\5\u00f2z\2\u0369\u0367\3\2\2\2"+
"\u0369\u036a\3\2\2\2\u036a\u036e\3\2\2\2\u036b\u036c\7\67\2\2\u036c\u036d"+
"\7)\2\2\u036d\u036f\5\u00eex\2\u036e\u036b\3\2\2\2\u036e\u036f\3\2\2\2"+
"\u036f\u0372\3\2\2\2\u0370\u0371\7p\2\2\u0371\u0373\5\u00fa~\2\u0372\u0370"+
"\3\2\2\2\u0372\u0373\3\2\2\2\u0373;\3\2\2\2\u0374\u0375\7r\2\2\u0375\u0379"+
"\7\u00c5\2\2\u0376\u0377\7\20\2\2\u0377\u037a\5\u01d0\u00e9\2\u0378\u037a"+
"\5\u01d0\u00e9\2\u0379\u0376\3\2\2\2\u0379\u0378\3\2\2\2\u0379\u037a\3"+
"\2\2\2\u037a\u037b\3\2\2\2\u037b\u037c\7R\2\2\u037c\u037f\5H%\2\u037d"+
"\u037e\7\17\2\2\u037e\u0380\5\u00c2b\2\u037f\u037d\3\2\2\2\u037f\u0380"+
"\3\2\2\2\u0380=\3\2\2\2\u0381\u0382\7\64\2\2\u0382\u0383\5\u00b2Z\2\u0383"+
"\u0384\7\32\2\2\u0384\u0386\5\u00c6d\2\u0385\u0387\5@!\2\u0386\u0385\3"+
"\2\2\2\u0386\u0387\3\2\2\2\u0387\u038a\3\2\2\2\u0388\u0389\7\17\2\2\u0389"+
"\u038b\5\u00c2b\2\u038a\u0388\3\2\2\2\u038a\u038b\3\2\2\2\u038b?\3\2\2"+
"\2\u038c\u038d\7 \2\2\u038d\u0391\5\u018c\u00c7\2\u038e\u038f\7\20\2\2"+
"\u038f\u0392\5\u01d0\u00e9\2\u0390\u0392\5\u01d0\u00e9\2\u0391\u038e\3"+
"\2\2\2\u0391\u0390\3\2\2\2\u0391\u0392\3\2\2\2\u0392A\3\2\2\2\u0393\u0396"+
"\7\60\2\2\u0394\u0397\7\62\2\2\u0395\u0397\7-\2\2\u0396\u0394\3\2\2\2"+
"\u0396\u0395\3\2\2\2\u0397C\3\2\2\2\u0398\u0399\7P\2\2\u0399\u039c\5L"+
"\'\2\u039a\u039b\7\17\2\2\u039b\u039d\5\u00c2b\2\u039c\u039a\3\2\2\2\u039c"+
"\u039d\3\2\2\2\u039dE\3\2\2\2\u039e\u039f\7R\2\2\u039f\u03a0\5H%\2\u03a0"+
"G\3\2\2\2\u03a1\u03a6\5J&\2\u03a2\u03a3\7\u0099\2\2\u03a3\u03a5\5J&\2"+
"\u03a4\u03a2\3\2\2\2\u03a5\u03a8\3\2\2\2\u03a6\u03a4\3\2\2\2\u03a6\u03a7"+
"\3\2\2\2\u03a7I\3\2\2\2\u03a8\u03a6\3\2\2\2\u03a9\u03aa\5\u01ca\u00e6"+
"\2\u03aa\u03ab\7\u008f\2\2\u03ab\u03ac\5\u0126\u0094\2\u03ac\u03af\3\2"+
"\2\2\u03ad\u03af\5\u0126\u0094\2\u03ae\u03a9\3\2\2\2\u03ae\u03ad\3\2\2"+
"\2\u03afK\3\2\2\2\u03b0\u03b1\7 \2\2\u03b1\u03b5\7\u00c5\2\2\u03b2\u03b3"+
"\7\20\2\2\u03b3\u03b6\5\u01d0\u00e9\2\u03b4\u03b6\5\u01d0\u00e9\2\u03b5"+
"\u03b2\3\2\2\2\u03b5\u03b4\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6M\3\2\2\2"+
"\u03b7\u03b8\7\3\2\2\u03b8\u03b9\7\4\2\2\u03b9\u03bb\7\u00c5\2\2\u03ba"+
"\u03bc\5\u00dan\2\u03bb\u03ba\3\2\2\2\u03bb\u03bc\3\2\2\2\u03bc\u03bf"+
"\3\2\2\2\u03bd\u03c0\7?\2\2\u03be\u03c0\7@\2\2\u03bf\u03bd\3\2\2\2\u03bf"+
"\u03be\3\2\2\2\u03bf\u03c0\3\2\2\2\u03c0\u03c2\3\2\2\2\u03c1\u03c3\7\20"+
"\2\2\u03c2\u03c1\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c9\3\2\2\2\u03c4"+
"\u03ca\5P)\2\u03c5\u03c6\7\u0092\2\2\u03c6\u03c7\5`\61\2\u03c7\u03c8\7"+
"\u0093\2\2\u03c8\u03ca\3\2\2\2\u03c9\u03c4\3\2\2\2\u03c9\u03c5\3\2\2\2"+
"\u03ca\u03d0\3\2\2\2\u03cb\u03ce\7\64\2\2\u03cc\u03cd\7\17\2\2\u03cd\u03cf"+
"\5\u0126\u0094\2\u03ce\u03cc\3\2\2\2\u03ce\u03cf\3\2\2\2\u03cf\u03d1\3"+
"\2\2\2\u03d0\u03cb\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1O\3\2\2\2\u03d2\u03d3"+
"\7\32\2\2\u03d3\u03d4\5d\63\2\u03d4\u03d5\7 \2\2\u03d5\u03d7\3\2\2\2\u03d6"+
"\u03d2\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03d8\3\2\2\2\u03d8\u03d9\5\u01a2"+
"\u00d2\2\u03d9Q\3\2\2\2\u03da\u03dc\7\3\2\2\u03db\u03dd\7\u00c5\2\2\u03dc"+
"\u03db\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03de\3\2\2\2\u03de\u03df\7W"+
"\2\2\u03df\u03e0\7\u00c5\2\2\u03e0\u03e1\7\'\2\2\u03e1\u03e2\7\u00c5\2"+
"\2\u03e2\u03e3\7\u0092\2\2\u03e3\u03e4\5T+\2\u03e4\u03e5\7\u0093\2\2\u03e5"+
"S\3\2\2\2\u03e6\u03eb\5V,\2\u03e7\u03e8\7\u0099\2\2\u03e8\u03ea\5V,\2"+
"\u03e9\u03e7\3\2\2\2\u03ea\u03ed\3\2\2\2\u03eb\u03e9\3\2\2\2\u03eb\u03ec"+
"\3\2\2\2\u03ecU\3\2\2\2\u03ed\u03eb\3\2\2\2\u03ee\u03f5\5\u0126\u0094"+
"\2\u03ef\u03f1\7\u0092\2\2\u03f0\u03f2\5\u01b0\u00d9\2\u03f1\u03f0\3\2"+
"\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f5\7\u0093\2\2\u03f4"+
"\u03ee\3\2\2\2\u03f4\u03ef\3\2\2\2\u03f5\u03fe\3\2\2\2\u03f6\u03fc\7\u00c5"+
"\2\2\u03f7\u03f9\7\u0092\2\2\u03f8\u03fa\5\u01b0\u00d9\2\u03f9\u03f8\3"+
"\2\2\2\u03f9\u03fa\3\2\2\2\u03fa\u03fb\3\2\2\2\u03fb\u03fd\7\u0093\2\2"+
"\u03fc\u03f7\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03ff\3\2\2\2\u03fe\u03f6"+
"\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ffW\3\2\2\2\u0400\u0402\7\3\2\2\u0401"+
"\u0403\7\u00c5\2\2\u0402\u0401\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0404"+
"\3\2\2\2\u0404\u0405\7S\2\2\u0405\u0406\5\u019e\u00d0\2\u0406\u0409\7"+
"\u00c5\2\2\u0407\u0408\7\u008f\2\2\u0408\u040a\5\u0126\u0094\2\u0409\u0407"+
"\3\2\2\2\u0409\u040a\3\2\2\2\u040aY\3\2\2\2\u040b\u040c\7\3\2\2\u040c"+
"\u040d\7T\2\2\u040d\u040f\7\u00c5\2\2\u040e\u0410\7\20\2\2\u040f\u040e"+
"\3\2\2\2\u040f\u0410\3\2\2\2\u0410\u0411\3\2\2\2\u0411\u0412\7\u0092\2"+
"\2\u0412\u0413\5\\/\2\u0413\u0414\7\u0093\2\2\u0414[\3\2\2\2\u0415\u041a"+
"\5^\60\2\u0416\u0417\7\u0099\2\2\u0417\u0419\5^\60\2\u0418\u0416\3\2\2"+
"\2\u0419\u041c\3\2\2\2\u041a\u0418\3\2\2\2\u041a\u041b\3\2\2\2\u041b]"+
"\3\2\2\2\u041c\u041a\3\2\2\2\u041d\u0421\7\u00c5\2\2\u041e\u0422\5\u019e"+
"\u00d0\2\u041f\u0422\5\u0154\u00ab\2\u0420\u0422\5\u015a\u00ae\2\u0421"+
"\u041e\3\2\2\2\u0421\u041f\3\2\2\2\u0421\u0420\3\2\2\2\u0422\u0424\3\2"+
"\2\2\u0423\u0425\7\u00c5\2\2\u0424\u0423\3\2\2\2\u0424\u0425\3\2\2\2\u0425"+
"\u0427\3\2\2\2\u0426\u0428\7\u00c5\2\2\u0427\u0426\3\2\2\2\u0427\u0428"+
"\3\2\2\2\u0428\u042d\3\2\2\2\u0429\u042c\5\u0198\u00cd\2\u042a\u042c\5"+
"\22\n\2\u042b\u0429\3\2\2\2\u042b\u042a\3\2\2\2\u042c\u042f\3\2\2\2\u042d"+
"\u042b\3\2\2\2\u042d\u042e\3\2\2\2\u042e_\3\2\2\2\u042f\u042d\3\2\2\2"+
"\u0430\u0435\5b\62\2\u0431\u0432\7\u0099\2\2\u0432\u0434\5b\62\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\u0436a\3\2\2\2\u0437\u0435\3\2\2\2\u0438\u043b\5\u01a2\u00d2\2\u0439"+
"\u043c\7o\2\2\u043a\u043c\5\u019e\u00d0\2\u043b\u0439\3\2\2\2\u043b\u043a"+
"\3\2\2\2\u043cc\3\2\2\2\u043d\u0442\5f\64\2\u043e\u043f\7\u0099\2\2\u043f"+
"\u0441\5f\64\2\u0440\u043e\3\2\2\2\u0441\u0444\3\2\2\2\u0442\u0440\3\2"+
"\2\2\u0442\u0443\3\2\2\2\u0443e\3\2\2\2\u0444\u0442\3\2\2\2\u0445\u0450"+
"\7\u00a6\2\2\u0446\u0449\5\u01ca\u00e6\2\u0447\u0448\7\20\2\2\u0448\u044a"+
"\7\u00c5\2\2\u0449\u0447\3\2\2\2\u0449\u044a\3\2\2\2\u044a\u0450\3\2\2"+
"\2\u044b\u044c\5\u01f2\u00fa\2\u044c\u044d\7\20\2\2\u044d\u044e\7\u00c5"+
"\2\2\u044e\u0450\3\2\2\2\u044f\u0445\3\2\2\2\u044f\u0446\3\2\2\2\u044f"+
"\u044b\3\2\2\2\u0450g\3\2\2\2\u0451\u0453\7\3\2\2\u0452\u0454\7\u00c5"+
"\2\2\u0453\u0452\3\2\2\2\u0453\u0454\3\2\2\2\u0454\u0455\3\2\2\2\u0455"+
"\u0456\5j\66\2\u0456i\3\2\2\2\u0457\u0458\7=\2\2\u0458\u045a\7\u00c5\2"+
"\2\u0459\u045b\7\20\2\2\u045a\u0459\3\2\2\2\u045a\u045b\3\2\2\2\u045b"+
"\u0462\3\2\2\2\u045c\u0463\5\u00acW\2\u045d\u045f\7\u0092\2\2\u045e\u0460"+
"\5`\61\2\u045f\u045e\3\2\2\2\u045f\u0460\3\2\2\2\u0460\u0461\3\2\2\2\u0461"+
"\u0463\7\u0093\2\2\u0462\u045c\3\2\2\2\u0462\u045d\3\2\2\2\u0463\u0467"+
"\3\2\2\2\u0464\u0466\5\u00aaV\2\u0465\u0464\3\2\2\2\u0466\u0469\3\2\2"+
"\2\u0467\u0465\3\2\2\2\u0467\u0468\3\2\2\2\u0468k\3\2\2\2\u0469\u0467"+
"\3\2\2\2\u046a\u046b\7P\2\2\u046b\u046c\7 \2\2\u046c\u0470\5\u01a2\u00d2"+
"\2\u046d\u046e\7\20\2\2\u046e\u0471\5\u01d0\u00e9\2\u046f\u0471\5\u01d0"+
"\u00e9\2\u0470\u046d\3\2\2\2\u0470\u046f\3\2\2\2\u0470\u0471\3\2\2\2\u0471"+
"\u0474\3\2\2\2\u0472\u0473\7\17\2\2\u0473\u0475\5\u00c2b\2\u0474\u0472"+
"\3\2\2\2\u0474\u0475\3\2\2\2\u0475m\3\2\2\2\u0476\u0477\7r\2\2\u0477\u0478"+
"\5(\25\2\u0478o\3\2\2\2\u0479\u047a\7\64\2\2\u047a\u047b\5\u00b2Z\2\u047b"+
"\u047c\7\66\2\2\u047c\u047d\7\u0092\2\2\u047d\u047e\5\u01b0\u00d9\2\u047e"+
"\u047f\7\u0093\2\2\u047fq\3\2\2\2\u0480\u0481\7\3\2\2\u0481\u0482\7\u0085"+
"\2\2\u0482\u0484\7\u00c5\2\2\u0483\u0485\7\20\2\2\u0484\u0483\3\2\2\2"+
"\u0484\u0485\3\2\2\2\u0485\u0486\3\2\2\2\u0486\u0487\5t;\2\u0487s\3\2"+
"\2\2\u0488\u048c\5v<\2\u0489\u048b\5v<\2\u048a\u0489\3\2\2\2\u048b\u048e"+
"\3\2\2\2\u048c\u048a\3\2\2\2\u048c\u048d\3\2\2\2\u048du\3\2\2\2\u048e"+
"\u048c\3\2\2\2\u048f\u0491\5\22\n\2\u0490\u048f\3\2\2\2\u0491\u0494\3"+
"\2\2\2\u0492\u0490\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u0497\3\2\2\2\u0494"+
"\u0492\3\2\2\2\u0495\u0498\7\u00c5\2\2\u0496\u0498\7\32\2\2\u0497\u0495"+
"\3\2\2\2\u0497\u0496\3\2\2\2\u0498\u049a\3\2\2\2\u0499\u049b\5x=\2\u049a"+
"\u0499\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u049d\3\2\2\2\u049c\u049e\5\u0082"+
"B\2\u049d\u049c\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u049f\3\2\2\2\u049f"+
"\u04a1\7\u0096\2\2\u04a0\u04a2\5\u008cG\2\u04a1\u04a0\3\2\2\2\u04a1\u04a2"+
"\3\2\2\2\u04a2\u04a4\3\2\2\2\u04a3\u04a5\7\u0099\2\2\u04a4\u04a3\3\2\2"+
"\2\u04a4\u04a5\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04ab\7\u0097\2\2\u04a7"+
"\u04a8\5h\65\2\u04a8\u04a9\7\u0099\2\2\u04a9\u04ab\3\2\2\2\u04aa\u0492"+
"\3\2\2\2\u04aa\u04a7\3\2\2\2\u04abw\3\2\2\2\u04ac\u04ad\7\u0092\2\2\u04ad"+
"\u04ae\5z>\2\u04ae\u04af\7\u0093\2\2\u04afy\3\2\2\2\u04b0\u04b5\5|?\2"+
"\u04b1\u04b2\7\u0099\2\2\u04b2\u04b4\5|?\2\u04b3\u04b1\3\2\2\2\u04b4\u04b7"+
"\3\2\2\2\u04b5\u04b3\3\2\2\2\u04b5\u04b6\3\2\2\2\u04b6{\3\2\2\2\u04b7"+
"\u04b5\3\2\2\2\u04b8\u04bb\5\u01a2\u00d2\2\u04b9\u04bb\5~@\2\u04ba\u04b8"+
"\3\2\2\2\u04ba\u04b9\3\2\2\2\u04bb\u04bd\3\2\2\2\u04bc\u04be\5\u0080A"+
"\2\u04bd\u04bc\3\2\2\2\u04bd\u04be\3\2\2\2\u04be}\3\2\2\2\u04bf\u04c0"+
"\7\u0092\2\2\u04c0\u04c1\5\u01a2\u00d2\2\u04c1\u04c2\7\u0099\2\2\u04c2"+
"\u04c3\5\u01a2\u00d2\2\u04c3\u04c4\3\2\2\2\u04c4\u04c5\7\u0093\2\2\u04c5"+
"\177\3\2\2\2\u04c6\u04c7\7\20\2\2\u04c7\u04c8\7\u00c5\2\2\u04c8\u0081"+
"\3\2\2\2\u04c9\u04ca\7\u008d\2\2\u04ca\u04cf\5\u0084C\2\u04cb\u04cc\7"+
"\u0099\2\2\u04cc\u04ce\5\u0084C\2\u04cd\u04cb\3\2\2\2\u04ce\u04d1\3\2"+
"\2\2\u04cf\u04cd\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u0083\3\2\2\2\u04d1"+
"\u04cf\3\2\2\2\u04d2\u04d4\5\u01a2\u00d2\2\u04d3\u04d5\5\u0086D\2\u04d4"+
"\u04d3\3\2\2\2\u04d4\u04d5\3\2\2\2\u04d5\u0085\3\2\2\2\u04d6\u04d7\7\u00ad"+
"\2\2\u04d7\u04dc\5\u0088E\2\u04d8\u04d9\7\u0099\2\2\u04d9\u04db\5\u0088"+
"E\2\u04da\u04d8\3\2\2\2\u04db\u04de\3\2\2\2\u04dc\u04da\3\2\2\2\u04dc"+
"\u04dd\3\2\2\2\u04dd\u04df\3\2\2\2\u04de\u04dc\3\2\2\2\u04df\u04e0\7\u00ab"+
"\2\2\u04e0\u0087\3\2\2\2\u04e1\u04e4\5\u008aF\2\u04e2\u04e4\7\u0091\2"+
"\2\u04e3\u04e1\3\2\2\2\u04e3\u04e2\3\2\2\2\u04e4\u0089\3\2\2\2\u04e5\u04e7"+
"\5\u01a2\u00d2\2\u04e6\u04e8\5\u0086D\2\u04e7\u04e6\3\2\2\2\u04e7\u04e8"+
"\3\2\2\2\u04e8\u008b\3\2\2\2\u04e9\u04ee\5\u008eH\2\u04ea\u04eb\7\u0099"+
"\2\2\u04eb\u04ed\5\u008eH\2\u04ec\u04ea\3\2\2\2\u04ed\u04f0\3\2\2\2\u04ee"+
"\u04ec\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u008d\3\2\2\2\u04f0\u04ee\3\2"+
"\2\2\u04f1\u04f2\7\32\2\2\u04f2\u04f3\t\3\2\2\u04f3\u04f4\7\u0092\2\2"+
"\u04f4\u04f5\5 \21\2\u04f5\u04f6\7\u0093\2\2\u04f6\u04ff\3\2\2\2\u04f7"+
"\u04f8\7\u00c5\2\2\u04f8\u04fc\t\3\2\2\u04f9\u04fd\5\u0126\u0094\2\u04fa"+
"\u04fd\5\u01fa\u00fe\2\u04fb\u04fd\5\u01fc\u00ff\2\u04fc\u04f9\3\2\2\2"+
"\u04fc\u04fa\3\2\2\2\u04fc\u04fb\3\2\2\2\u04fd\u04ff\3\2\2\2\u04fe\u04f1"+
"\3\2\2\2\u04fe\u04f7\3\2\2\2\u04ff\u008f\3\2\2\2\u0500\u0501\7\3\2\2\u0501"+
"\u0502\7\u0082\2\2\u0502\u0504\7\u00c5\2\2\u0503\u0505\7\20\2\2\u0504"+
"\u0503\3\2\2\2\u0504\u0505\3\2\2\2\u0505\u0506\3\2\2\2\u0506\u0507\5\u0094"+
"K\2\u0507\u0091\3\2\2\2\u0508\u0509\7\3\2\2\u0509\u050a\5\b\5\2\u050a"+
"\u0093\3\2\2\2\u050b\u0517\5\u0098M\2\u050c\u050d\5\u0096L\2\u050d\u050e"+
"\7\u0099\2\2\u050e\u0513\5\u0096L\2\u050f\u0510\7\u0099\2\2\u0510\u0512"+
"\5\u0096L\2\u0511\u050f\3\2\2\2\u0512\u0515\3\2\2\2\u0513\u0511\3\2\2"+
"\2\u0513\u0514\3\2\2\2\u0514\u0517\3\2\2\2\u0515\u0513\3\2\2\2\u0516\u050b"+
"\3\2\2\2\u0516\u050c\3\2\2\2\u0517\u0095\3\2\2\2\u0518\u0519\7\u0082\2"+
"\2\u0519\u051b\7\u00c5\2\2\u051a\u051c\7\20\2\2\u051b\u051a\3\2\2\2\u051b"+
"\u051c\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051e\5\u0098M\2\u051e\u0097"+
"\3\2\2\2\u051f\u0523\7\u0081\2\2\u0520\u0521\7\u00bd\2\2\u0521\u0524\7"+
"\u00c5\2\2\u0522\u0524\5\u009cO\2\u0523\u0520\3\2\2\2\u0523\u0522\3\2"+
"\2\2\u0524\u0527\3\2\2\2\u0525\u0526\7\37\2\2\u0526\u0528\5\u009cO\2\u0527"+
"\u0525\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u056c\3\2\2\2\u0529\u052b\7\u0083"+
"\2\2\u052a\u052c\7)\2\2\u052b\u052a\3\2\2\2\u052b\u052c\3\2\2\2\u052c"+
"\u052e\3\2\2\2\u052d\u052f\5\u009aN\2\u052e\u052d\3\2\2\2\u052e\u052f"+
"\3\2\2\2\u052f\u0533\3\2\2\2\u0530\u0531\7\u00bd\2\2\u0531\u0532\7\u00c5"+
"\2\2\u0532\u0534\7\13\2\2\u0533\u0530\3\2\2\2\u0533\u0534\3\2\2\2\u0534"+
"\u0535\3\2\2\2\u0535\u053b\5\u009cO\2\u0536\u0538\7\u0084\2\2\u0537\u0539"+
"\7)\2\2\u0538\u0537\3\2\2\2\u0538\u0539\3\2\2\2\u0539\u053a\3\2\2\2\u053a"+
"\u053c\5\u009cO\2\u053b\u0536\3\2\2\2\u053b\u053c\3\2\2\2\u053c\u056c"+
"\3\2\2\2\u053d\u053f\7w\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\u0546\5\u00a0Q\2\u0542\u0543"+
"\7\u0099\2\2\u0543\u0545\5\u00a0Q\2\u0544\u0542\3\2\2\2\u0545\u0548\3"+
"\2\2\2\u0546\u0544\3\2\2\2\u0546\u0547\3\2\2\2\u0547\u054a\3\2\2\2\u0548"+
"\u0546\3\2\2\2\u0549\u054b\5\u00a6T\2\u054a\u0549\3\2\2\2\u054a\u054b"+
"\3\2\2\2\u054b\u054d\3\2\2\2\u054c\u054e\5\u00a8U\2\u054d\u054c\3\2\2"+
"\2\u054d\u054e\3\2\2\2\u054e\u056c\3\2\2\2\u054f\u0554\5\u00a4S\2\u0550"+
"\u0551\7\u0099\2\2\u0551\u0553\5\u00a4S\2\u0552\u0550\3\2\2\2\u0553\u0556"+
"\3\2\2\2\u0554\u0552\3\2\2\2\u0554\u0555\3\2\2\2\u0555\u0557\3\2\2\2\u0556"+
"\u0554\3\2\2\2\u0557\u0558\7 \2\2\u0558\u0559\5\u018a\u00c6\2\u0559\u056c"+
"\3\2\2\2\u055a\u055c\7\25\2\2\u055b\u055d\7)\2\2\u055c\u055b\3\2\2\2\u055c"+
"\u055d\3\2\2\2\u055d\u055e\3\2\2\2\u055e\u0563\5\u00a2R\2\u055f\u0560"+
"\7\u0099\2\2\u0560\u0562\5\u00a2R\2\u0561\u055f\3\2\2\2\u0562\u0565\3"+
"\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0566\3\2\2\2\u0565"+
"\u0563\3\2\2\2\u0566\u0567\7\u00c5\2\2\u0567\u0569\5\u01ec\u00f7\2\u0568"+
"\u056a\7\u00c5\2\2\u0569\u0568\3\2\2\2\u0569\u056a\3\2\2\2\u056a\u056c"+
"\3\2\2\2\u056b\u051f\3\2\2\2\u056b\u0529\3\2\2\2\u056b\u053d\3\2\2\2\u056b"+
"\u054f\3\2\2\2\u056b\u055a\3\2\2\2\u056c\u0099\3\2\2\2\u056d\u056e\7,"+
"\2\2\u056e\u0570\7\u0092\2\2\u056f\u0571\5\u01b0\u00d9\2\u0570\u056f\3"+
"\2\2\2\u0570\u0571\3\2\2\2\u0571\u0572\3\2\2\2\u0572\u0573\7\u0093\2\2"+
"\u0573\u009b\3\2\2\2\u0574\u057e\5\u009eP\2\u0575\u0578\5\u00d4k\2\u0576"+
"\u0577\7\u00bd\2\2\u0577\u0579\7\u00c5\2\2\u0578\u0576\3\2\2\2\u0578\u0579"+
"\3\2\2\2\u0579\u057e\3\2\2\2\u057a\u057e\5\u00fc\177\2\u057b\u057c\7y"+
"\2\2\u057c\u057e\5\u01d8\u00ed\2\u057d\u0574\3\2\2\2\u057d\u0575\3\2\2"+
"\2\u057d\u057a\3\2\2\2\u057d\u057b\3\2\2\2\u057e\u009d\3\2\2\2\u057f\u0584"+
"\5\u018a\u00c6\2\u0580\u0582\7\20\2\2\u0581\u0580\3\2\2\2\u0581\u0582"+
"\3\2\2\2\u0582\u0583\3\2\2\2\u0583\u0585\7\u00c5\2\2\u0584\u0581\3\2\2"+
"\2\u0584\u0585\3\2\2\2\u0585\u009f\3\2\2\2\u0586\u058b\5\u01ca\u00e6\2"+
"\u0587\u0588\t\4\2\2\u0588\u058a\5\u01ca\u00e6\2\u0589\u0587\3\2\2\2\u058a"+
"\u058d\3\2\2\2\u058b\u0589\3\2\2\2\u058b\u058c\3\2\2\2\u058c\u058e\3\2"+
"\2\2\u058d\u058b\3\2\2\2\u058e\u058f\7 \2\2\u058f\u0594\5\u018a\u00c6"+
"\2\u0590\u0592\7\20\2\2\u0591\u0590\3\2\2\2\u0591\u0592\3\2\2\2\u0592"+
"\u0593\3\2\2\2\u0593\u0595\5\u01d2\u00ea\2\u0594\u0591\3\2\2\2\u0594\u0595"+
"\3\2\2\2\u0595\u00a1\3\2\2\2\u0596\u0597\5\u015e\u00b0\2\u0597\u0598\7"+
" \2\2\u0598\u0599\5\u018a\u00c6\2\u0599\u00a3\3\2\2\2\u059a\u059c\7*\2"+
"\2\u059b\u059d\7)\2\2\u059c\u059b\3\2\2\2\u059c\u059d\3\2\2\2\u059d\u059e"+
"\3\2\2\2\u059e\u059f\5\u0126\u0094\2\u059f\u05a0\7\20\2\2\u05a0\u05a1"+
"\7\u00c5\2\2\u05a1\u00a5\3\2\2\2\u05a2\u05a4\7\u0083\2\2\u05a3\u05a5\7"+
")\2\2\u05a4\u05a3\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6"+
"\u05ab\5\u009eP\2\u05a7\u05a8\7\u0099\2\2\u05a8\u05aa\5\u009eP\2\u05a9"+
"\u05a7\3\2\2\2\u05aa\u05ad\3\2\2\2\u05ab\u05a9\3\2\2\2\u05ab\u05ac\3\2"+
"\2\2\u05ac\u00a7\3\2\2\2\u05ad\u05ab\3\2\2\2\u05ae\u05b0\7\u0084\2\2\u05af"+
"\u05b1\7)\2\2\u05b0\u05af\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b2\3\2"+
"\2\2\u05b2\u05b3\5\u009cO\2\u05b3\u00a9\3\2\2\2\u05b4\u05b5\7\u00c5\2"+
"\2\u05b5\u05b6\5\u00b4[\2\u05b6\u00ab\3\2\2\2\u05b7\u05bc\5\u00aeX\2\u05b8"+
"\u05b9\7\u0099\2\2\u05b9\u05bb\5\u00aeX\2\u05ba\u05b8\3\2\2\2\u05bb\u05be"+
"\3\2\2\2\u05bc\u05ba\3\2\2\2\u05bc\u05bd\3\2\2\2\u05bd\u00ad\3\2\2\2\u05be"+
"\u05bc\3\2\2\2\u05bf\u05c2\7\u00a6\2\2\u05c0\u05c2\5\u01a2\u00d2\2\u05c1"+
"\u05bf\3\2\2\2\u05c1\u05c0\3\2\2\2\u05c2\u00af\3\2\2\2\u05c3\u05c4\7T"+
"\2\2\u05c4\u05c5\7\u00c5\2\2\u05c5\u00b1\3\2\2\2\u05c6\u05ca\7;\2\2\u05c7"+
"\u05ca\7:\2\2\u05c8\u05ca\7<\2\2\u05c9\u05c6\3\2\2\2\u05c9\u05c7\3\2\2"+
"\2\u05c9\u05c8\3\2\2\2\u05c9\u05ca\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cc"+
"\7\65\2\2\u05cc\u05d2\5\u01a2\u00d2\2\u05cd\u05cf\7\u0092\2\2\u05ce\u05d0"+
"\5\u00b4[\2\u05cf\u05ce\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u05d1\3\2\2"+
"\2\u05d1\u05d3\7\u0093\2\2\u05d2\u05cd\3\2\2\2\u05d2\u05d3\3\2\2\2\u05d3"+
"\u00b3\3\2\2\2\u05d4\u05d9\7\u00c5\2\2\u05d5\u05d6\7\u0099\2\2\u05d6\u05d8"+
"\7\u00c5\2\2\u05d7\u05d5\3\2\2\2\u05d8\u05db\3\2\2\2\u05d9\u05d7\3\2\2"+
"\2\u05d9\u05da\3\2\2\2\u05da\u00b5\3\2\2\2\u05db\u05d9\3\2\2\2\u05dc\u05df"+
"\5\u00d0i\2\u05dd\u05e0\5\u00b8]\2\u05de\u05e0\5\u00ba^\2\u05df\u05dd"+
"\3\2\2\2\u05df\u05de\3\2\2\2\u05e0\u00b7\3\2\2\2\u05e1\u05e2\7\u0099\2"+
"\2\u05e2\u05e4\5\u00d0i\2\u05e3\u05e1\3\2\2\2\u05e4\u05e7\3\2\2\2\u05e5"+
"\u05e3\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6\u00b9\3\2\2\2\u05e7\u05e5\3\2"+
"\2\2\u05e8\u05ec\5\u00bc_\2\u05e9\u05eb\5\u00bc_\2\u05ea\u05e9\3\2\2\2"+
"\u05eb\u05ee\3\2\2\2\u05ec\u05ea\3\2\2\2\u05ec\u05ed\3\2\2\2\u05ed\u00bb"+
"\3\2\2\2\u05ee\u05ec\3\2\2\2\u05ef\u05f3\7$\2\2\u05f0\u05f3\7%\2\2\u05f1"+
"\u05f3\7&\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
"\2\2\u05f3\u05f4\3\2\2\2\u05f4\u05f6\7!\2\2\u05f5\u05f2\3\2\2\2\u05f5"+
"\u05f6\3\2\2\2\u05f6\u05f9\3\2\2\2\u05f7\u05f9\7\"\2\2\u05f8\u05f5\3\2"+
"\2\2\u05f8\u05f7\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fb\7#\2\2\u05fb"+
"\u05fd\5\u00d0i\2\u05fc\u05fe\5\u00be`\2\u05fd\u05fc\3\2\2\2\u05fd\u05fe"+
"\3\2\2\2\u05fe\u00bd\3\2\2\2\u05ff\u0600\7\'\2\2\u0600\u0605\5\u00c0a"+
"\2\u0601\u0602\7\13\2\2\u0602\u0604\5\u00c0a\2\u0603\u0601\3\2\2\2\u0604"+
"\u0607\3\2\2\2\u0605\u0603\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u00bf\3\2"+
"\2\2\u0607\u0605\3\2\2\2\u0608\u0609\5\u01ca\u00e6\2\u0609\u060a\7\u008f"+
"\2\2\u060a\u060b\5\u01ca\u00e6\2\u060b\u00c1\3\2\2\2\u060c\u060d\5\u012a"+
"\u0096\2\u060d\u00c3\3\2\2\2\u060e\u0612\7:\2\2\u060f\u0612\7;\2\2\u0610"+
"\u0612\7<\2\2\u0611\u060e\3\2\2\2\u0611\u060f\3\2\2\2\u0611\u0610\3\2"+
"\2\2\u0611\u0612\3\2\2\2\u0612\u0614\3\2\2\2\u0613\u0615\7,\2\2\u0614"+
"\u0613\3\2\2\2\u0614\u0615\3\2\2\2\u0615\u0616\3\2\2\2\u0616\u0617\5\u00c6"+
"d\2\u0617\u00c5\3\2\2\2\u0618\u061d\5\u00c8e\2\u0619\u061a\7\u0099\2\2"+
"\u061a\u061c\5\u00c8e\2\u061b\u0619\3\2\2\2\u061c\u061f\3\2\2\2\u061d"+
"\u061b\3\2\2\2\u061d\u061e\3\2\2\2\u061e\u00c7\3\2\2\2\u061f\u061d\3\2"+
"\2\2\u0620\u0624\7\u00a6\2\2\u0621\u0624\5\u00ceh\2\u0622\u0624\5\u00ca"+
"f\2\u0623\u0620\3\2\2\2\u0623\u0621\3\2\2\2\u0623\u0622\3\2\2\2\u0624"+
"\u00c9\3\2\2\2\u0625\u0627\5\u0126\u0094\2\u0626\u0628\5\u00ccg\2\u0627"+
"\u0626\3\2\2\2\u0627\u0628\3\2\2\2\u0628\u062d\3\2\2\2\u0629\u062b\7\20"+
"\2\2\u062a\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b\u062c\3\2\2\2\u062c"+
"\u062e\5\u01d2\u00ea\2\u062d\u062a\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u00cb"+
"\3\2\2\2\u062f\u0630\7\u00bd\2\2\u0630\u0631\7\u00c5\2\2\u0631\u00cd\3"+
"\2\2\2\u0632\u0633\7\u00c5\2\2\u0633\u0634\7\u00b7\2\2\u0634\u0637\7\u00a6"+
"\2\2\u0635\u0636\7\20\2\2\u0636\u0638\7\u00c5\2\2\u0637\u0635\3\2\2\2"+
"\u0637\u0638\3\2\2\2\u0638\u00cf\3\2\2\2\u0639\u063e\5\u018a\u00c6\2\u063a"+
"\u063e\5\u00d4k\2\u063b\u063e\5\u00d6l\2\u063c\u063e\5\u00d8m\2\u063d"+
"\u0639\3\2\2\2\u063d\u063a\3\2\2\2\u063d\u063b\3\2\2\2\u063d\u063c\3\2"+
"\2\2\u063e\u0640\3\2\2\2\u063f\u0641\5\u00dan\2\u0640\u063f\3\2\2\2\u0640"+
"\u0641\3\2\2\2\u0641\u0645\3\2\2\2\u0642\u0643\7\20\2\2\u0643\u0646\5"+
"\u01d0\u00e9\2\u0644\u0646\5\u01d0\u00e9\2\u0645\u0642\3\2\2\2\u0645\u0644"+
"\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0648\3\2\2\2\u0647\u0649\7>\2\2\u0648"+
"\u0647\3\2\2\2\u0648\u0649\3\2\2\2\u0649\u064c\3\2\2\2\u064a\u064d\7?"+
"\2\2\u064b\u064d\7@\2\2\u064c\u064a\3\2\2\2\u064c\u064b\3\2\2\2\u064c"+
"\u064d\3\2\2\2\u064d\u00d1\3\2\2\2\u064e\u064f\7z\2\2\u064f\u0655\7\u00c5"+
"\2\2\u0650\u0652\7\u0092\2\2\u0651\u0653\5\u01b0\u00d9\2\u0652\u0651\3"+
"\2\2\2\u0652\u0653\3\2\2\2\u0653\u0654\3\2\2\2\u0654\u0656\7\u0093\2\2"+
"\u0655\u0650\3\2\2\2\u0655\u0656\3\2\2\2\u0656\u00d3\3\2\2\2\u0657\u065b"+
"\7A\2\2\u0658\u065a\5\22\n\2\u0659\u0658\3\2\2\2\u065a\u065d\3\2\2\2\u065b"+
"\u0659\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065e\3\2\2\2\u065d\u065b\3\2"+
"\2\2\u065e\u065f\7\u0094\2\2\u065f\u0660\5\u016c\u00b7\2\u0660\u0661\7"+
"\u0095\2\2\u0661\u00d5\3\2\2\2\u0662\u0663\7B\2\2\u0663\u0664\7\u0098"+
"\2\2\u0664\u0665\7\u00c5\2\2\u0665\u0668\7\u0094\2\2\u0666\u0669\7\u00c4"+
"\2\2\u0667\u0669\7\u00c3\2\2\u0668\u0666\3\2\2\2\u0668\u0667\3\2\2\2\u0669"+
"\u066f\3\2\2\2\u066a\u066d\7C\2\2\u066b\u066e\7\u00c4\2\2\u066c\u066e"+
"\7\u00c3\2\2\u066d\u066b\3\2\2\2\u066d\u066c\3\2\2\2\u066e\u0670\3\2\2"+
"\2\u066f\u066a\3\2\2\2\u066f\u0670\3\2\2\2\u0670\u0671\3\2\2\2\u0671\u0672"+
"\7\u0095\2\2\u0672\u00d7\3\2\2\2\u0673\u0674\7\u00c5\2\2\u0674\u0675\7"+
"\u0098\2\2\u0675\u067b\5\u01a2\u00d2\2\u0676\u0678\7\u0092\2\2\u0677\u0679"+
"\5\u01b0\u00d9\2\u0678\u0677\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067a\3"+
"\2\2\2\u067a\u067c\7\u0093\2\2\u067b\u0676\3\2\2\2\u067b\u067c\3\2\2\2"+
"\u067c\u067e\3\2\2\2\u067d\u067f\5\u0198\u00cd\2\u067e\u067d\3\2\2\2\u067e"+
"\u067f\3\2\2\2\u067f\u00d9\3\2\2\2\u0680\u0681\7\u00b7\2\2\u0681\u0686"+
"\5\u00dco\2\u0682\u0683\7\u00b7\2\2\u0683\u0685\5\u00dco\2\u0684\u0682"+
"\3\2\2\2\u0685\u0688\3\2\2\2\u0686\u0684\3\2\2\2\u0686\u0687\3\2\2\2\u0687"+
"\u0693\3\2\2\2\u0688\u0686\3\2\2\2\u0689\u068a\7\u00be\2\2\u068a\u068f"+
"\5\u00dep\2\u068b\u068c\7\u00be\2\2\u068c\u068e\5\u00dep\2\u068d\u068b"+
"\3\2\2\2\u068e\u0691\3\2\2\2\u068f\u068d\3\2\2\2\u068f\u0690\3\2\2\2\u0690"+
"\u0693\3\2\2\2\u0691\u068f\3\2\2\2\u0692\u0680\3\2\2\2\u0692\u0689\3\2"+
"\2\2\u0693\u00db\3\2\2\2\u0694\u0695\7\u00c5\2\2\u0695\u0696\7\u0098\2"+
"\2\u0696\u0697\5\u00e0q\2\u0697\u00dd\3\2\2\2\u0698\u0699\7\u00c5\2\2"+
"\u0699\u069b\7\u0098\2\2\u069a\u0698\3\2\2\2\u069a\u069b\3\2\2\2\u069b"+
"\u069c\3\2\2\2\u069c\u069d\5\u00e0q\2\u069d\u00df\3\2\2\2\u069e\u06a1"+
"\7\u00c5\2\2\u069f\u06a1\7}\2\2\u06a0\u069e\3\2\2\2\u06a0\u069f\3\2\2"+
"\2\u06a1\u06a7\3\2\2\2\u06a2\u06a4\7\u0092\2\2\u06a3\u06a5\5\u01b2\u00da"+
"\2\u06a4\u06a3\3\2\2\2\u06a4\u06a5\3\2\2\2\u06a5\u06a6\3\2\2\2\u06a6\u06a8"+
"\7\u0093\2\2\u06a7\u06a2\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8\u00e1\3\2\2"+
"\2\u06a9\u06ae\5\u00e4s\2\u06aa\u06ab\7\u0099\2\2\u06ab\u06ad\5\u00e4"+
"s\2\u06ac\u06aa\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06ae"+
"\u06af\3\2\2\2\u06af\u00e3\3\2\2\2\u06b0\u06ae\3\2\2\2\u06b1\u06b5\5\u0126"+
"\u0094\2\u06b2\u06b5\5\u00e6t\2\u06b3\u06b5\5\u00e8u\2\u06b4\u06b1\3\2"+
"\2\2\u06b4\u06b2\3\2\2\2\u06b4\u06b3\3\2\2\2\u06b5\u00e5\3\2\2\2\u06b6"+
"\u06b7\t\5\2\2\u06b7\u06b8\7\u0092\2\2\u06b8\u06bd\5\u00ecw\2\u06b9\u06ba"+
"\7\u0099\2\2\u06ba\u06bc\5\u00ecw\2\u06bb\u06b9\3\2\2\2\u06bc\u06bf\3"+
"\2\2\2\u06bd\u06bb\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u06c0\3\2\2\2\u06bf"+
"\u06bd\3\2\2\2\u06c0\u06c1\7\u0093\2\2\u06c1\u00e7\3\2\2\2\u06c2\u06c3"+
"\7\u0088\2\2\u06c3\u06c4\7\u008a\2\2\u06c4\u06c5\7\u0092\2\2\u06c5\u06ca"+
"\5\u00eav\2\u06c6\u06c7\7\u0099\2\2\u06c7\u06c9\5\u00eav\2\u06c8\u06c6"+
"\3\2\2\2\u06c9\u06cc\3\2\2\2\u06ca\u06c8\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cb"+
"\u06cd\3\2\2\2\u06cc\u06ca\3\2\2\2\u06cd\u06ce\7\u0093\2\2\u06ce\u00e9"+
"\3\2\2\2\u06cf\u06d2\5\u00e6t\2\u06d0\u06d2\5\u00ecw\2\u06d1\u06cf\3\2"+
"\2\2\u06d1\u06d0\3\2\2\2\u06d2\u00eb\3\2\2\2\u06d3\u06e1\5\u0126\u0094"+
"\2\u06d4\u06dd\7\u0092\2\2\u06d5\u06da\5\u0126\u0094\2\u06d6\u06d7\7\u0099"+
"\2\2\u06d7\u06d9\5\u0126\u0094\2\u06d8\u06d6\3\2\2\2\u06d9\u06dc\3\2\2"+
"\2\u06da\u06d8\3\2\2\2\u06da\u06db\3\2\2\2\u06db\u06de\3\2\2\2\u06dc\u06da"+
"\3\2\2\2\u06dd\u06d5\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u06df\3\2\2\2\u06df"+
"\u06e1\7\u0093\2\2\u06e0\u06d3\3\2\2\2\u06e0\u06d4\3\2\2\2\u06e1\u00ed"+
"\3\2\2\2\u06e2\u06e7\5\u00f0y\2\u06e3\u06e4\7\u0099\2\2\u06e4\u06e6\5"+
"\u00f0y\2\u06e5\u06e3\3\2\2\2\u06e6\u06e9\3\2\2\2\u06e7\u06e5\3\2\2\2"+
"\u06e7\u06e8\3\2\2\2\u06e8\u00ef\3\2\2\2\u06e9\u06e7\3\2\2\2\u06ea\u06ed"+
"\5\u0126\u0094\2\u06eb\u06ee\78\2\2\u06ec\u06ee\79\2\2\u06ed\u06eb\3\2"+
"\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee\u00f1\3\2\2\2\u06ef"+
"\u06f0\5\u012a\u0096\2\u06f0\u00f3\3\2\2\2\u06f1\u06f3\5\u00f8}\2\u06f2"+
"\u06f1\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f8\3\2\2\2\u06f4\u06f9\7-"+
"\2\2\u06f5\u06f9\7\62\2\2\u06f6\u06f9\7\63\2\2\u06f7\u06f9\7Q\2\2\u06f8"+
"\u06f4\3\2\2\2\u06f8\u06f5\3\2\2\2\u06f8\u06f6\3\2\2\2\u06f8\u06f7\3\2"+
"\2\2\u06f8\u06f9\3\2\2\2\u06f9\u0716\3\2\2\2\u06fa\u0701\7\r\2\2\u06fb"+
"\u0702\5\u01d8\u00ed\2\u06fc\u06ff\5\u01ec\u00f7\2\u06fd\u06ff\7\u00c5"+
"\2\2\u06fe\u06fc\3\2\2\2\u06fe\u06fd\3\2\2\2\u06ff\u0700\3\2\2\2\u0700"+
"\u0702\7\61\2\2\u0701\u06fb\3\2\2\2\u0701\u06fe\3\2\2\2\u0702\u0717\3"+
"\2\2\2\u0703\u0704\7V\2\2\u0704\u0717\5\u00fe\u0080\2\u0705\u0706\7\35"+
"\2\2\u0706\u0709\5\u0126\u0094\2\u0707\u0708\7\36\2\2\u0708\u070a\5F$"+
"\2\u0709\u0707\3\2\2\2\u0709\u070a\3\2\2\2\u070a\u0717\3\2\2\2\u070b\u070c"+
"\7\35\2\2\u070c\u070f\7\u0084\2\2\u070d\u070e\7\13\2\2\u070e\u0710\5\u0126"+
"\u0094\2\u070f\u070d\3\2\2\2\u070f\u0710\3\2\2\2\u0710\u0713\3\2\2\2\u0711"+
"\u0712\7\36\2\2\u0712\u0714\5F$\2\u0713\u0711\3\2\2\2\u0713\u0714\3\2"+
"\2\2\u0714\u0717\3\2\2\2\u0715\u0717\3\2\2\2\u0716\u06fa\3\2\2\2\u0716"+
"\u0703\3\2\2\2\u0716\u0705\3\2\2\2\u0716\u070b\3\2\2\2\u0716\u0715\3\2"+
"\2\2\u0717\u0719\3\2\2\2\u0718\u071a\5\u00f6|\2\u0719\u0718\3\2\2\2\u0719"+
"\u071a\3\2\2\2\u071a\u00f5\3\2\2\2\u071b\u071c\7\13\2\2\u071c\u071d\7"+
"\35\2\2\u071d\u0720\7\u0084\2\2\u071e\u071f\7\13\2\2\u071f\u0721\5\u0126"+
"\u0094\2\u0720\u071e\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0724\3\2\2\2\u0722"+
"\u0723\7\36\2\2\u0723\u0725\5F$\2\u0724\u0722\3\2\2\2\u0724\u0725\3\2"+
"\2\2\u0725\u00f7\3\2\2\2\u0726\u072b\7y\2\2\u0727\u072c\5\u01d8\u00ed"+
"\2\u0728\u0729\5\u01ec\u00f7\2\u0729\u072a\7\61\2\2\u072a\u072c\3\2\2"+
"\2\u072b\u0727\3\2\2\2\u072b\u0728\3\2\2\2\u072c\u00f9\3\2\2\2\u072d\u0730"+
"\5\u01f4\u00fb\2\u072e\u0730\7\u00c5\2\2\u072f\u072d\3\2\2\2\u072f\u072e"+
"\3\2\2\2\u0730\u0739\3\2\2\2\u0731\u0734\7\u0099\2\2\u0732\u0734\7q\2"+
"\2\u0733\u0731\3\2\2\2\u0733\u0732\3\2\2\2\u0734\u0737\3\2\2\2\u0735\u0738"+
"\5\u01f4\u00fb\2\u0736\u0738\7\u00c5\2\2\u0737\u0735\3\2\2\2\u0737\u0736"+
"\3\2\2\2\u0738\u073a\3\2\2\2\u0739\u0733\3\2\2\2\u0739\u073a\3\2\2\2\u073a"+
"\u00fb\3\2\2\2\u073b\u0740\5\u00fe\u0080\2\u073c\u073d\7\u0099\2\2\u073d"+
"\u073f\5\u00fe\u0080\2\u073e\u073c\3\2\2\2\u073f\u0742\3\2\2\2\u0740\u073e"+
"\3\2\2\2\u0740\u0741\3\2\2\2\u0741\u00fd\3\2\2\2\u0742\u0740\3\2\2\2\u0743"+
"\u0744\7\u0092\2\2\u0744\u0745\5\u01b2\u00da\2\u0745\u0746\7\u0093\2\2"+
"\u0746\u00ff\3\2\2\2\u0747\u0748\7\35\2\2\u0748\u0749\5\u0126\u0094\2"+
"\u0749\u074a\7\36\2\2\u074a\u074b\5\u0126\u0094\2\u074b\u0101\3\2\2\2"+
"\u074c\u074d\7\34\2\2\u074d\u074e\5\u0126\u0094\2\u074e\u0103\3\2\2\2"+
"\u074f\u0750\7s\2\2\u0750\u0752\7\u0092\2\2\u0751\u0753\5\u0106\u0084"+
"\2\u0752\u0751\3\2\2\2\u0752\u0753\3\2\2\2\u0753\u0754\3\2\2\2\u0754\u0756"+
"\5\u0108\u0085\2\u0755\u0757\5\u010c\u0087\2\u0756\u0755\3\2\2\2\u0756"+
"\u0757\3\2\2\2\u0757\u0759\3\2\2\2\u0758\u075a\5\u0110\u0089\2\u0759\u0758"+
"\3\2\2\2\u0759\u075a\3\2\2\2\u075a\u075b\3\2\2\2\u075b\u075d\5\u010e\u0088"+
"\2\u075c\u075e\5\u0112\u008a\2\u075d\u075c\3\2\2\2\u075d\u075e\3\2\2\2"+
"\u075e\u0760\3\2\2\2\u075f\u0761\5\u0122\u0092\2\u0760\u075f\3\2\2\2\u0760"+
"\u0761\3\2\2\2\u0761\u0762\3\2\2\2\u0762\u0763\7\u0093\2\2\u0763\u0105"+
"\3\2\2\2\u0764\u0765\7w\2\2\u0765\u0766\7)\2\2\u0766\u076b\5\u0126\u0094"+
"\2\u0767\u0768\7\u0099\2\2\u0768\u076a\5\u0126\u0094\2\u0769\u0767\3\2"+
"\2\2\u076a\u076d\3\2\2\2\u076b\u0769\3\2\2\2\u076b\u076c\3\2\2\2\u076c"+
"\u0107\3\2\2\2\u076d\u076b\3\2\2\2\u076e\u076f\7u\2\2\u076f\u0774\5\u010a"+
"\u0086\2\u0770\u0771\7\u0099\2\2\u0771\u0773\5\u010a\u0086\2\u0772\u0770"+
"\3\2\2\2\u0773\u0776\3\2\2\2\u0774\u0772\3\2\2\2\u0774\u0775\3\2\2\2\u0775"+
"\u0109\3\2\2\2\u0776\u0774\3\2\2\2\u0777\u077c\5\u0126\u0094\2\u0778\u077a"+
"\7\20\2\2\u0779\u077b\7\u00c5\2\2\u077a\u0779\3\2\2\2\u077a\u077b\3\2"+
"\2\2\u077b\u077d\3\2\2\2\u077c\u0778\3\2\2\2\u077c\u077d\3\2\2\2\u077d"+
"\u010b\3\2\2\2\u077e\u077f\7-\2\2\u077f\u0780\7x\2\2\u0780\u010d\3\2\2"+
"\2\u0781\u0782\7A\2\2\u0782\u0783\7\u0092\2\2\u0783\u0784\5\u0114\u008b"+
"\2\u0784\u0785\7\u0093\2\2\u0785\u010f\3\2\2\2\u0786\u0787\7y\2\2\u0787"+
"\u0788\5\u01d2\u00ea\2\u0788\u0789\5\u01d2\u00ea\2\u0789\u078a\5\u01d2"+
"\u00ea\2\u078a\u078b\5\u01d2\u00ea\2\u078b\u078c\5\u01d2\u00ea\2\u078c"+
"\u0111\3\2\2\2\u078d\u078e\7\u00c5\2\2\u078e\u0791\5\u01d8\u00ed\2\u078f"+
"\u0790\7\n\2\2\u0790\u0792\7\u0084\2\2\u0791\u078f\3\2\2\2\u0791\u0792"+
"\3\2\2\2\u0792\u0113\3\2\2\2\u0793\u0798\5\u0116\u008c\2\u0794\u0795\7"+
"\u00b0\2\2\u0795\u0797\5\u0116\u008c\2\u0796\u0794\3\2\2\2\u0797\u079a"+
"\3\2\2\2\u0798\u0796\3\2\2\2\u0798\u0799\3\2\2\2\u0799\u0115\3\2\2\2\u079a"+
"\u0798\3\2\2\2\u079b\u079d\5\u0118\u008d\2\u079c\u079b\3\2\2\2\u079d\u079e"+
"\3\2\2\2\u079e\u079c\3\2\2\2\u079e\u079f\3\2\2\2\u079f\u0117\3\2\2\2\u07a0"+
"\u07a4\5\u011c\u008f\2\u07a1\u07a4\5\u011a\u008e\2\u07a2\u07a4\5\u011e"+
"\u0090\2\u07a3\u07a0\3\2\2\2\u07a3\u07a1\3\2\2\2\u07a3\u07a2\3\2\2\2\u07a4"+
"\u0119\3\2\2\2\u07a5\u07a6\7\u0092\2\2\u07a6\u07a7\5\u0114\u008b\2\u07a7"+
"\u07ab\7\u0093\2\2\u07a8\u07ac\7\u00a6\2\2\u07a9\u07ac\7\u00a0\2\2\u07aa"+
"\u07ac\7\u0091\2\2\u07ab\u07a8\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07aa"+
"\3\2\2\2\u07ab\u07ac\3\2\2\2\u07ac\u07ae\3\2\2\2\u07ad\u07af\5\u0120\u0091"+
"\2\u07ae\u07ad\3\2\2\2\u07ae\u07af\3\2\2\2\u07af\u011b\3\2\2\2\u07b0\u07b1"+
"\7t\2\2\u07b1\u07b2\7\u0092\2\2\u07b2\u07b7\5\u0114\u008b\2\u07b3\u07b4"+
"\7\u0099\2\2\u07b4\u07b6\5\u0114\u008b\2\u07b5\u07b3\3\2\2\2\u07b6\u07b9"+
"\3\2\2\2\u07b7\u07b5\3\2\2\2\u07b7\u07b8\3\2\2\2\u07b8\u07ba\3\2\2\2\u07b9"+
"\u07b7\3\2\2\2\u07ba\u07bb\7\u0093\2\2\u07bb\u011d\3\2\2\2\u07bc\u07c5"+
"\7\u00c5\2\2\u07bd\u07c1\7\u00a6\2\2\u07be\u07c1\7\u00a0\2\2\u07bf\u07c1"+
"\7\u0091\2\2\u07c0\u07bd\3\2\2\2\u07c0\u07be\3\2\2\2\u07c0\u07bf\3\2\2"+
"\2\u07c1\u07c3\3\2\2\2\u07c2\u07c4\7\u0091\2\2\u07c3\u07c2\3\2\2\2\u07c3"+
"\u07c4\3\2\2\2\u07c4\u07c6\3\2\2\2\u07c5\u07c0\3\2\2\2\u07c5\u07c6\3\2"+
"\2\2\u07c6\u07c8\3\2\2\2\u07c7\u07c9\5\u0120\u0091\2\u07c8\u07c7\3\2\2"+
"\2\u07c8\u07c9\3\2\2\2\u07c9\u011f\3\2\2\2\u07ca\u07cc\7\u0096\2\2\u07cb"+
"\u07cd\5\u0126\u0094\2\u07cc\u07cb\3\2\2\2\u07cc\u07cd\3\2\2\2\u07cd\u07cf"+
"\3\2\2\2\u07ce\u07d0\7\u0099\2\2\u07cf\u07ce\3\2\2\2\u07cf\u07d0\3\2\2"+
"\2\u07d0\u07d2\3\2\2\2\u07d1\u07d3\5\u0126\u0094\2\u07d2\u07d1\3\2\2\2"+
"\u07d2\u07d3\3\2\2\2\u07d3\u07d4\3\2\2\2\u07d4\u07d5\7\u0097\2\2\u07d5"+
"\u0121\3\2\2\2\u07d6\u07d7\7v\2\2\u07d7\u07dc\5\u0124\u0093\2\u07d8\u07d9"+
"\7\u0099\2\2\u07d9\u07db\5\u0124\u0093\2\u07da\u07d8\3\2\2\2\u07db\u07de"+
"\3\2\2\2\u07dc\u07da\3\2\2\2\u07dc\u07dd\3\2\2\2\u07dd\u0123\3\2\2\2\u07de"+
"\u07dc\3\2\2\2\u07df\u07e0\7\u00c5\2\2\u07e0\u07e1\7\20\2\2\u07e1\u07e2"+
"\5\u0126\u0094\2\u07e2\u0125\3\2\2\2\u07e3\u07e4\5\u0128\u0095\2\u07e4"+
"\u0127\3\2\2\2\u07e5\u07e6\b\u0095\1\2\u07e6\u07e8\7\33\2\2\u07e7\u07e9"+
"\5\u0100\u0081\2\u07e8\u07e7\3\2\2\2\u07e9\u07ea\3\2\2\2\u07ea\u07e8\3"+
"\2\2\2\u07ea\u07eb\3\2\2\2\u07eb\u07ed\3\2\2\2\u07ec\u07ee\5\u0102\u0082"+
"\2\u07ed\u07ec\3\2\2\2\u07ed\u07ee\3\2\2\2\u07ee\u07ef\3\2\2\2\u07ef\u07f0"+
"\7\37\2\2\u07f0\u07f1\b\u0095\1\2\u07f1\u0802\3\2\2\2\u07f2\u07f3\b\u0095"+
"\1\2\u07f3\u07f4\7\33\2\2\u07f4\u07f6\5\u0126\u0094\2\u07f5\u07f7\5\u0100"+
"\u0081\2\u07f6\u07f5\3\2\2\2\u07f7\u07f8\3\2\2\2\u07f8\u07f6\3\2\2\2\u07f8"+
"\u07f9\3\2\2\2\u07f9\u07fb\3\2\2\2\u07fa\u07fc\5\u0102\u0082\2\u07fb\u07fa"+
"\3\2\2\2\u07fb\u07fc\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u07fe\7\37\2\2"+
"\u07fe\u07ff\b\u0095\1\2\u07ff\u0802\3\2\2\2\u0800\u0802\5\u012a\u0096"+
"\2\u0801\u07e5\3\2\2\2\u0801\u07f2\3\2\2\2\u0801\u0800\3\2\2\2\u0802\u0129"+
"\3\2\2\2\u0803\u0808\5\u012c\u0097\2\u0804\u0805\7\n\2\2\u0805\u0807\5"+
"\u012c\u0097\2\u0806\u0804\3\2\2\2\u0807\u080a\3\2\2\2\u0808\u0806\3\2"+
"\2\2\u0808\u0809\3\2\2\2\u0809\u012b\3\2\2\2\u080a\u0808\3\2\2\2\u080b"+
"\u0810\5\u012e\u0098\2\u080c\u080d\7\13\2\2\u080d\u080f\5\u012e\u0098"+
"\2\u080e\u080c\3\2\2\2\u080f\u0812\3\2\2\2\u0810\u080e\3\2\2\2\u0810\u0811"+
"\3\2\2\2\u0811\u012d\3\2\2\2\u0812\u0810\3\2\2\2\u0813\u0818\5\u0130\u0099"+
"\2\u0814\u0815\t\6\2\2\u0815\u0817\5\u0130\u0099\2\u0816\u0814\3\2\2\2"+
"\u0817\u081a\3\2\2\2\u0818\u0816\3\2\2\2\u0818\u0819\3\2\2\2\u0819\u012f"+
"\3\2\2\2\u081a\u0818\3\2\2\2\u081b\u081f\5\u0132\u009a\2\u081c\u081d\7"+
"\f\2\2\u081d\u081f\5\u0132\u009a\2\u081e\u081b\3\2\2\2\u081e\u081c\3\2"+
"\2\2\u081f\u0131\3\2\2\2\u0820\u083b\5\u0134\u009b\2\u0821\u0828\7\u008f"+
"\2\2\u0822\u0828\7(\2\2\u0823\u0824\7(\2\2\u0824\u0828\7\f\2\2\u0825\u0828"+
"\7\u0090\2\2\u0826\u0828\7\u009d\2\2\u0827\u0821\3\2\2\2\u0827\u0822\3"+
"\2\2\2\u0827\u0823\3\2\2\2\u0827\u0825\3\2\2\2\u0827\u0826\3\2\2\2\u0828"+
"\u0837\3\2\2\2\u0829\u0838\5\u0134\u009b\2\u082a\u082e\7.\2\2\u082b\u082e"+
"\7/\2\2\u082c\u082e\7-\2\2\u082d\u082a\3\2\2\2\u082d\u082b\3\2\2\2\u082d"+
"\u082c\3\2\2\2\u082e\u0835\3\2\2\2\u082f\u0831\7\u0092\2\2\u0830\u0832"+
"\5\u01b0\u00d9\2\u0831\u0830\3\2\2\2\u0831\u0832\3\2\2\2\u0832\u0833\3"+
"\2\2\2\u0833\u0836\7\u0093\2\2\u0834\u0836\5\u014a\u00a6\2\u0835\u082f"+
"\3\2\2\2\u0835\u0834\3\2\2\2\u0836\u0838\3\2\2\2\u0837\u0829\3\2\2\2\u0837"+
"\u082d\3\2\2\2\u0838\u083a\3\2\2\2\u0839\u0827\3\2\2\2\u083a\u083d\3\2"+
"\2\2\u083b\u0839\3\2\2\2\u083b\u083c\3\2\2\2\u083c\u0133\3\2\2\2\u083d"+
"\u083b\3\2\2\2\u083e\u0880\5\u0138\u009d\2\u083f\u0844\7\u00ad\2\2\u0840"+
"\u0844\7\u00ab\2\2\u0841\u0844\7\u00ac\2\2\u0842\u0844\7\u00aa\2\2\u0843"+
"\u083f\3\2\2\2\u0843\u0840\3\2\2\2\u0843\u0841\3\2\2\2\u0843\u0842\3\2"+
"\2\2\u0844\u0853\3\2\2\2\u0845\u0854\5\u0138\u009d\2\u0846\u084a\7.\2"+
"\2\u0847\u084a\7/\2\2\u0848\u084a\7-\2\2\u0849\u0846\3\2\2\2\u0849\u0847"+
"\3\2\2\2\u0849\u0848\3\2\2\2\u084a\u0851\3\2\2\2\u084b\u084d\7\u0092\2"+
"\2\u084c\u084e\5\u01b0\u00d9\2\u084d\u084c\3\2\2\2\u084d\u084e\3\2\2\2"+
"\u084e\u084f\3\2\2\2\u084f\u0852\7\u0093\2\2\u0850\u0852\5\u014a\u00a6"+
"\2\u0851\u084b\3\2\2\2\u0851\u0850\3\2\2\2\u0852\u0854\3\2\2\2\u0853\u0845"+
"\3\2\2\2\u0853\u0849\3\2\2\2\u0854\u0856\3\2\2\2\u0855\u0843\3\2\2\2\u0856"+
"\u0859\3\2\2\2\u0857\u0855\3\2\2\2\u0857\u0858\3\2\2\2\u0858\u0881\3\2"+
"\2\2\u0859\u0857\3\2\2\2\u085a\u085c\7\f\2\2\u085b\u085a\3\2\2\2\u085b"+
"\u085c\3\2\2\2\u085c\u087e\3\2\2\2\u085d\u0860\7\5\2\2\u085e\u0861\7\u0092"+
"\2\2\u085f\u0861\7\u0094\2\2\u0860\u085e\3\2\2\2\u0860\u085f\3\2\2\2\u0861"+
"\u0862\3\2\2\2\u0862\u086c\5\u0126\u0094\2\u0863\u0864\7\u0098\2\2\u0864"+
"\u086d\5\u0126\u0094\2\u0865\u0866\7\u0099\2\2\u0866\u0868\5\u0126\u0094"+
"\2\u0867\u0865\3\2\2\2\u0868\u086b\3\2\2\2\u0869\u0867\3\2\2\2\u0869\u086a"+
"\3\2\2\2\u086a\u086d\3\2\2\2\u086b\u0869\3\2\2\2\u086c\u0863\3\2\2\2\u086c"+
"\u0869\3\2\2\2\u086d\u0870\3\2\2\2\u086e\u0871\7\u0093\2\2\u086f\u0871"+
"\7\u0095\2\2\u0870\u086e\3\2\2\2\u0870\u086f\3\2\2\2\u0871\u087f\3\2\2"+
"\2\u0872\u0873\7\5\2\2\u0873\u087f\5\u0136\u009c\2\u0874\u0875\7\6\2\2"+
"\u0875\u087f\5\u016a\u00b6\2\u0876\u0877\7\7\2\2\u0877\u087a\5\u0138\u009d"+
"\2\u0878\u0879\7\t\2\2\u0879\u087b\5\u01f6\u00fc\2\u087a\u0878\3\2\2\2"+
"\u087a\u087b\3\2\2\2\u087b\u087f\3\2\2\2\u087c\u087d\7\b\2\2\u087d\u087f"+
"\5\u0138\u009d\2\u087e\u085d\3\2\2\2\u087e\u0872\3\2\2\2\u087e\u0874\3"+
"\2\2\2\u087e\u0876\3\2\2\2\u087e\u087c\3\2\2\2\u087f\u0881\3\2\2\2\u0880"+
"\u0857\3\2\2\2\u0880\u085b\3\2\2\2\u0881\u0135\3\2\2\2\u0882\u0883\5\u014e"+
"\u00a8\2\u0883\u0137\3\2\2\2\u0884\u088e\5\u013a\u009e\2\u0885\u0886\7"+
"\u00b2\2\2\u0886\u088b\5\u013a\u009e\2\u0887\u0888\7\u00b2\2\2\u0888\u088a"+
"\5\u013a\u009e\2\u0889\u0887\3\2\2\2\u088a\u088d\3\2\2\2\u088b\u0889\3"+
"\2\2\2\u088b\u088c\3\2\2\2\u088c\u088f\3\2\2\2\u088d\u088b\3\2\2\2\u088e"+
"\u0885\3\2\2\2\u088e\u088f\3\2\2\2\u088f\u0139\3\2\2\2\u0890\u0895\5\u013c"+
"\u009f\2\u0891\u0892\t\7\2\2\u0892\u0894\5\u013c\u009f\2\u0893\u0891\3"+
"\2\2\2\u0894\u0897\3\2\2\2\u0895\u0893\3\2\2\2\u0895\u0896\3\2\2\2\u0896"+
"\u013b\3\2\2\2\u0897\u0895\3\2\2\2\u0898\u089d\5\u013e\u00a0\2\u0899\u089a"+
"\t\b\2\2\u089a\u089c\5\u013e\u00a0\2\u089b\u0899\3\2\2\2\u089c\u089f\3"+
"\2\2\2\u089d\u089b\3\2\2\2\u089d\u089e\3\2\2\2\u089e\u013d\3\2\2\2\u089f"+
"\u089d\3\2\2\2\u08a0\u08db\5\u0140\u00a1\2\u08a1\u08db\5\u01f2\u00fa\2"+
"\u08a2\u08db\5\u0142\u00a2\2\u08a3\u08a4\7\u0092\2\2\u08a4\u08a5\5\u0126"+
"\u0094\2\u08a5\u08a7\7\u0093\2\2\u08a6\u08a8\5\u0144\u00a3\2\u08a7\u08a6"+
"\3\2\2\2\u08a7\u08a8\3\2\2\2\u08a8\u08db\3\2\2\2\u08a9\u08db\5\u0154\u00ab"+
"\2\u08aa\u08db\5\u0158\u00ad\2\u08ab\u08db\5\u0152\u00aa\2\u08ac\u08db"+
"\5\u0148\u00a5\2\u08ad\u08db\5\u014c\u00a7\2\u08ae\u08af\7\u0080\2\2\u08af"+
"\u08b0\7\u0096\2\2\u08b0\u08b5\5\u0146\u00a4\2\u08b1\u08b2\7\u0099\2\2"+
"\u08b2\u08b4\5\u0146\u00a4\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\u08b9\7\u0097\2\2\u08b9\u08db\3\2\2\2\u08ba\u08bb\7\u0080\2"+
"\2\u08bb\u08bc\5\u01a2\u00d2\2\u08bc\u08c5\7\u0092\2\2\u08bd\u08c2\5\u0126"+
"\u0094\2\u08be\u08bf\7\u0099\2\2\u08bf\u08c1\5\u0126\u0094\2\u08c0\u08be"+
"\3\2\2\2\u08c1\u08c4\3\2\2\2\u08c2\u08c0\3\2\2\2\u08c2\u08c3\3\2\2\2\u08c3"+
"\u08c6\3\2\2\2\u08c4\u08c2\3\2\2\2\u08c5\u08bd\3\2\2\2\u08c5\u08c6\3\2"+
"\2\2\u08c6\u08c7\3\2\2\2\u08c7\u08c9\7\u0093\2\2\u08c8\u08ca\5\u0144\u00a3"+
"\2\u08c9\u08c8\3\2\2\2\u08c9\u08ca\3\2\2\2\u08ca\u08db\3\2\2\2\u08cb\u08cc"+
"\7\u00c5\2\2\u08cc\u08cd\7\u0094\2\2\u08cd\u08d2\5\u0126\u0094\2\u08ce"+
"\u08cf\7\u0099\2\2\u08cf\u08d1\5\u0126\u0094\2\u08d0\u08ce\3\2\2\2\u08d1"+
"\u08d4\3\2\2\2\u08d2\u08d0\3\2\2\2\u08d2\u08d3\3\2\2\2\u08d3\u08d5\3\2";
private static final String _serializedATNSegment1 =
"\2\2\u08d4\u08d2\3\2\2\2\u08d5\u08d7\7\u0095\2\2\u08d6\u08d8\5\u0144\u00a3"+
"\2\u08d7\u08d6\3\2\2\2\u08d7\u08d8\3\2\2\2\u08d8\u08db\3\2\2\2\u08d9\u08db"+
"\5\u01fa\u00fe\2\u08da\u08a0\3\2\2\2\u08da\u08a1\3\2\2\2\u08da\u08a2\3"+
"\2\2\2\u08da\u08a3\3\2\2\2\u08da\u08a9\3\2\2\2\u08da\u08aa\3\2\2\2\u08da"+
"\u08ab\3\2\2\2\u08da\u08ac\3\2\2\2\u08da\u08ad\3\2\2\2\u08da\u08ae\3\2"+
"\2\2\u08da\u08ba\3\2\2\2\u08da\u08cb\3\2\2\2\u08da\u08d9\3\2\2\2\u08db"+
"\u013f\3\2\2\2\u08dc\u08dd\7\u00a3\2\2\u08dd\u08de\5\u01ca\u00e6\2\u08de"+
"\u0141\3\2\2\2\u08df\u08e1\5\u01ee\u00f8\2\u08e0\u08e2\5\u0144\u00a3\2"+
"\u08e1\u08e0\3\2\2\2\u08e1\u08e2\3\2\2\2\u08e2\u0143\3\2\2\2\u08e3\u08e4"+
"\7\u00b7\2\2\u08e4\u08e9\5\u015e\u00b0\2\u08e5\u08e6\7\u00b7\2\2\u08e6"+
"\u08e8\5\u015e\u00b0\2\u08e7\u08e5\3\2\2\2\u08e8\u08eb\3\2\2\2\u08e9\u08e7"+
"\3\2\2\2\u08e9\u08ea\3\2\2\2\u08ea\u0145\3\2\2\2\u08eb\u08e9\3\2\2\2\u08ec"+
"\u08ef\5\u01ca\u00e6\2\u08ed\u08ee\7\u008f\2\2\u08ee\u08f0\5\u0126\u0094"+
"\2\u08ef\u08ed\3\2\2\2\u08ef\u08f0\3\2\2\2\u08f0\u0147\3\2\2\2\u08f1\u08f3"+
"\5\u014e\u00a8\2\u08f2\u08f4\5\u0144\u00a3\2\u08f3\u08f2\3\2\2\2\u08f3"+
"\u08f4\3\2\2\2\u08f4\u0149\3\2\2\2\u08f5\u08f6\5\u014e\u00a8\2\u08f6\u014b"+
"\3\2\2\2\u08f7\u08f8\7I\2\2\u08f8\u08f9\5\u014e\u00a8\2\u08f9\u014d\3"+
"\2\2\2\u08fa\u08fb\7\u0092\2\2\u08fb\u08fd\7\32\2\2\u08fc\u08fe\7,\2\2"+
"\u08fd\u08fc\3\2\2\2\u08fd\u08fe\3\2\2\2\u08fe\u08ff\3\2\2\2\u08ff\u0900"+
"\5\u00c6d\2\u0900\u0901\7 \2\2\u0901\u0904\5\u0150\u00a9\2\u0902\u0903"+
"\7\17\2\2\u0903\u0905\5\u00c2b\2\u0904\u0902\3\2\2\2\u0904\u0905\3\2\2"+
"\2\u0905\u0909\3\2\2\2\u0906\u0907\7*\2\2\u0907\u0908\7)\2\2\u0908\u090a"+
"\5\u00e2r\2\u0909\u0906\3\2\2\2\u0909\u090a\3\2\2\2\u090a\u090d\3\2\2"+
"\2\u090b\u090c\7+\2\2\u090c\u090e\5\u00f2z\2\u090d\u090b\3\2\2\2\u090d"+
"\u090e\3\2\2\2\u090e\u090f\3\2\2\2\u090f\u0910\7\u0093\2\2\u0910\u014f"+
"\3\2\2\2\u0911\u0913\5\u018a\u00c6\2\u0912\u0914\5\u00dan\2\u0913\u0912"+
"\3\2\2\2\u0913\u0914\3\2\2\2\u0914\u0918\3\2\2\2\u0915\u0916\7\20\2\2"+
"\u0916\u0919\5\u01d0\u00e9\2\u0917\u0919\5\u01d0\u00e9\2\u0918\u0915\3"+
"\2\2\2\u0918\u0917\3\2\2\2\u0918\u0919\3\2\2\2\u0919\u091c\3\2\2\2\u091a"+
"\u091d\7?\2\2\u091b\u091d\7@\2\2\u091c\u091a\3\2\2\2\u091c\u091b\3\2\2"+
"\2\u091c\u091d\3\2\2\2\u091d\u0151\3\2\2\2\u091e\u0927\7\u0096\2\2\u091f"+
"\u0924\5\u0126\u0094\2\u0920\u0921\7\u0099\2\2\u0921\u0923\5\u0126\u0094"+
"\2\u0922\u0920\3\2\2\2\u0923\u0926\3\2\2\2\u0924\u0922\3\2\2\2\u0924\u0925"+
"\3\2\2\2\u0925\u0928\3\2\2\2\u0926\u0924\3\2\2\2\u0927\u091f\3\2\2\2\u0927"+
"\u0928\3\2\2\2\u0928\u0929\3\2\2\2\u0929\u092b\7\u0097\2\2\u092a\u092c"+
"\5\u0144\u00a3\2\u092b\u092a\3\2\2\2\u092b\u092c\3\2\2\2\u092c\u0153\3"+
"\2\2\2\u092d\u092e\7\21\2\2\u092e\u0930\7\u0092\2\2\u092f\u0931\t\t\2"+
"\2\u0930\u092f\3\2\2\2\u0930\u0931\3\2\2\2\u0931\u0932\3\2\2\2\u0932\u0933"+
"\5\u01a4\u00d3\2\u0933\u0934\7\u0093\2\2\u0934\u09d1\3\2\2\2\u0935\u0936"+
"\7\22\2\2\u0936\u0938\7\u0092\2\2\u0937\u0939\t\t\2\2\u0938\u0937\3\2"+
"\2\2\u0938\u0939\3\2\2\2\u0939\u093a\3\2\2\2\u093a\u093b\5\u01a4\u00d3"+
"\2\u093b\u093c\7\u0093\2\2\u093c\u09d1\3\2\2\2\u093d\u093e\7\31\2\2\u093e"+
"\u0941\7\u0092\2\2\u093f\u0942\7-\2\2\u0940\u0942\7,\2\2\u0941\u093f\3"+
"\2\2\2\u0941\u0940\3\2\2\2\u0941\u0942\3\2\2\2\u0942\u0943\3\2\2\2\u0943"+
"\u0944\5\u01a4\u00d3\2\u0944\u0945\7\u0093\2\2\u0945\u09d1\3\2\2\2\u0946"+
"\u0947\7\26\2\2\u0947\u0949\7\u0092\2\2\u0948\u094a\t\t\2\2\u0949\u0948"+
"\3\2\2\2\u0949\u094a\3\2\2\2\u094a\u094b\3\2\2\2\u094b\u094c\5\u01a4\u00d3"+
"\2\u094c\u094d\7\u0093\2\2\u094d\u09d1\3\2\2\2\u094e\u094f\7\27\2\2\u094f"+
"\u0951\7\u0092\2\2\u0950\u0952\t\t\2\2\u0951\u0950\3\2\2\2\u0951\u0952"+
"\3\2\2\2\u0952\u0953\3\2\2\2\u0953\u0954\5\u01a4\u00d3\2\u0954\u0955\7"+
"\u0093\2\2\u0955\u09d1\3\2\2\2\u0956\u0957\7\30\2\2\u0957\u0959\7\u0092"+
"\2\2\u0958\u095a\t\t\2\2\u0959\u0958\3\2\2\2\u0959\u095a\3\2\2\2\u095a"+
"\u095b\3\2\2\2\u095b\u095c\5\u01a4\u00d3\2\u095c\u095d\7\u0093\2\2\u095d"+
"\u09d1\3\2\2\2\u095e\u09d1\5\u0156\u00ac\2\u095f\u0960\7\25\2\2\u0960"+
"\u0961\7\u0092\2\2\u0961\u0962\5\u0126\u0094\2\u0962\u0963\7\u0099\2\2"+
"\u0963\u0968\5\u0126\u0094\2\u0964\u0965\7\u0099\2\2\u0965\u0967\5\u0126"+
"\u0094\2\u0966\u0964\3\2\2\2\u0967\u096a\3\2\2\2\u0968\u0966\3\2\2\2\u0968"+
"\u0969\3\2\2\2\u0969\u096b\3\2\2\2\u096a\u0968\3\2\2\2\u096b\u096c\7\u0093"+
"\2\2\u096c\u09d1\3\2\2\2\u096d\u096e\7D\2\2\u096e\u096f\7\u0092\2\2\u096f"+
"\u0972\5\u0126\u0094\2\u0970\u0971\7\u0099\2\2\u0971\u0973\5\u0126\u0094"+
"\2\u0972\u0970\3\2\2\2\u0972\u0973\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u0976"+
"\7\u0093\2\2\u0975\u0977\5\u0144\u00a3\2\u0976\u0975\3\2\2\2\u0976\u0977"+
"\3\2\2\2\u0977\u09d1\3\2\2\2\u0978\u0979\7E\2\2\u0979\u097a\7\u0092\2"+
"\2\u097a\u097d\5\u0126\u0094\2\u097b\u097c\7\u0099\2\2\u097c\u097e\5\u0126"+
"\u0094\2\u097d\u097b\3\2\2\2\u097d\u097e\3\2\2\2\u097e\u097f\3\2\2\2\u097f"+
"\u0981\7\u0093\2\2\u0980\u0982\5\u0144\u00a3\2\u0981\u0980\3\2\2\2\u0981"+
"\u0982\3\2\2\2\u0982\u09d1\3\2\2\2\u0983\u0984\7F\2\2\u0984\u0985\7\u0092"+
"\2\2\u0985\u0986\5\u0126\u0094\2\u0986\u0987\7\u0093\2\2\u0987\u09d1\3"+
"\2\2\2\u0988\u0989\7G\2\2\u0989\u098a\7\u0092\2\2\u098a\u098b\5\u0126"+
"\u0094\2\u098b\u098d\7\u0093\2\2\u098c\u098e\5\u0144\u00a3\2\u098d\u098c"+
"\3\2\2\2\u098d\u098e\3\2\2\2\u098e\u09d1\3\2\2\2\u098f\u0990\7H\2\2\u0990"+
"\u0991\7\u0092\2\2\u0991\u0992\5\u0126\u0094\2\u0992\u0993\7\u0099\2\2"+
"\u0993\u0994\5\u01ca\u00e6\2\u0994\u0995\7\u0093\2\2\u0995\u09d1\3\2\2"+
"\2\u0996\u0997\7\u0088\2\2\u0997\u0998\7\u0092\2\2\u0998\u0999\5\u0126"+
"\u0094\2\u0999\u099a\7\u0093\2\2\u099a\u09d1\3\2\2\2\u099b\u099c\7\u0089"+
"\2\2\u099c\u099d\7\u0092\2\2\u099d\u099e\5\u01b0\u00d9\2\u099e\u099f\7"+
"\u0093\2\2\u099f\u09d1\3\2\2\2\u09a0\u09a1\7L\2\2\u09a1\u09a2\7\u0092"+
"\2\2\u09a2\u09a3\5\u0126\u0094\2\u09a3\u09a4\7\u0099\2\2\u09a4\u09a9\5"+
"\u01a2\u00d2\2\u09a5\u09a6\7\u0099\2\2\u09a6\u09a8\5\u01a2\u00d2\2\u09a7"+
"\u09a5\3\2\2\2\u09a8\u09ab\3\2\2\2\u09a9\u09a7\3\2\2\2\u09a9\u09aa\3\2"+
"\2\2\u09aa\u09ac\3\2\2\2\u09ab\u09a9\3\2\2\2\u09ac\u09ad\7\u0093\2\2\u09ad"+
"\u09d1\3\2\2\2\u09ae\u09af\7M\2\2\u09af\u09b0\7\u0092\2\2\u09b0\u09b1"+
"\5\u0126\u0094\2\u09b1\u09b2\7\u0093\2\2\u09b2\u09d1\3\2\2\2\u09b3\u09b4"+
"\7N\2\2\u09b4\u09b5\7\u0092\2\2\u09b5\u09b6\5\u0126\u0094\2\u09b6\u09b7"+
"\t\n\2\2\u09b7\u09ba\5\u019e\u00d0\2\u09b8\u09b9\7\u0099\2\2\u09b9\u09bb"+
"\5\u01ac\u00d7\2\u09ba\u09b8\3\2\2\2\u09ba\u09bb\3\2\2\2\u09bb\u09bc\3"+
"\2\2\2\u09bc\u09be\7\u0093\2\2\u09bd\u09bf\5\u0144\u00a3\2\u09be\u09bd"+
"\3\2\2\2\u09be\u09bf\3\2\2\2\u09bf\u09d1\3\2\2\2\u09c0\u09c1\7I\2\2\u09c1"+
"\u09c2\7\u0092\2\2\u09c2\u09c3\5\u01ca\u00e6\2\u09c3\u09c4\7\u0093\2\2"+
"\u09c4\u09d1\3\2\2\2\u09c5\u09c8\7O\2\2\u09c6\u09c7\7\u0092\2\2\u09c7"+
"\u09c9\7\u0093\2\2\u09c8\u09c6\3\2\2\2\u09c8\u09c9\3\2\2\2\u09c9\u09cb"+
"\3\2\2\2\u09ca\u09cc\5\u0144\u00a3\2\u09cb\u09ca\3\2\2\2\u09cb\u09cc\3"+
"\2\2\2\u09cc\u09d1\3\2\2\2\u09cd\u09ce\7;\2\2\u09ce\u09cf\7\u0092\2\2"+
"\u09cf\u09d1\7\u0093\2\2\u09d0\u092d\3\2\2\2\u09d0\u0935\3\2\2\2\u09d0"+
"\u093d\3\2\2\2\u09d0\u0946\3\2\2\2\u09d0\u094e\3\2\2\2\u09d0\u0956\3\2"+
"\2\2\u09d0\u095e\3\2\2\2\u09d0\u095f\3\2\2\2\u09d0\u096d\3\2\2\2\u09d0"+
"\u0978\3\2\2\2\u09d0\u0983\3\2\2\2\u09d0\u0988\3\2\2\2\u09d0\u098f\3\2"+
"\2\2\u09d0\u0996\3\2\2\2\u09d0\u099b\3\2\2\2\u09d0\u09a0\3\2\2\2\u09d0"+
"\u09ae\3\2\2\2\u09d0\u09b3\3\2\2\2\u09d0\u09c0\3\2\2\2\u09d0\u09c5\3\2"+
"\2\2\u09d0\u09cd\3\2\2\2\u09d1\u0155\3\2\2\2\u09d2\u09d6\7\62\2\2\u09d3"+
"\u09d6\7\63\2\2\u09d4\u09d6\7\4\2\2\u09d5\u09d2\3\2\2\2\u09d5\u09d3\3"+
"\2\2\2\u09d5\u09d4\3\2\2\2\u09d6\u09d7\3\2\2\2\u09d7\u09d9\7\u0092\2\2"+
"\u09d8\u09da\5\u01a4\u00d3\2\u09d9\u09d8\3\2\2\2\u09d9\u09da\3\2\2\2\u09da"+
"\u09db\3\2\2\2\u09db\u09dd\7\u0093\2\2\u09dc\u09de\5\u0144\u00a3\2\u09dd"+
"\u09dc\3\2\2\2\u09dd\u09de\3\2\2\2\u09de\u0157\3\2\2\2\u09df\u09e2\5\u01ca"+
"\u00e6\2\u09e0\u09e2\5\u015a\u00ae\2\u09e1\u09df\3\2\2\2\u09e1\u09e0\3"+
"\2\2\2\u09e2\u0159\3\2\2\2\u09e3\u09e8\5\u015c\u00af\2\u09e4\u09e5\7\u00b7"+
"\2\2\u09e5\u09e7\5\u015e\u00b0\2\u09e6\u09e4\3\2\2\2\u09e7\u09ea\3\2\2"+
"\2\u09e8\u09e6\3\2\2\2\u09e8\u09e9\3\2\2\2\u09e9\u015b\3\2\2\2\u09ea\u09e8"+
"\3\2\2\2\u09eb\u09ec\5\u01a2\u00d2\2\u09ec\u09ed\7\u00b7\2\2\u09ed\u09ee"+
"\5\u0162\u00b2\2\u09ee\u09f1\3\2\2\2\u09ef\u09f1\5\u0160\u00b1\2\u09f0"+
"\u09eb\3\2\2\2\u09f0\u09ef\3\2\2\2\u09f1\u09f7\3\2\2\2\u09f2\u09f4\7\u0092"+
"\2\2\u09f3\u09f5\5\u0166\u00b4\2\u09f4\u09f3\3\2\2\2\u09f4\u09f5\3\2\2"+
"\2\u09f5\u09f6\3\2\2\2\u09f6\u09f8\7\u0093\2\2\u09f7\u09f2\3\2\2\2\u09f7"+
"\u09f8\3\2\2\2\u09f8\u015d\3\2\2\2\u09f9\u09ff\5\u0164\u00b3\2\u09fa\u09fc"+
"\7\u0092\2\2\u09fb\u09fd\5\u0166\u00b4\2\u09fc\u09fb\3\2\2\2\u09fc\u09fd"+
"\3\2\2\2\u09fd\u09fe\3\2\2\2\u09fe\u0a00\7\u0093\2\2\u09ff\u09fa\3\2\2"+
"\2\u09ff\u0a00\3\2\2\2\u0a00\u015f\3\2\2\2\u0a01\u0a05\5\u01d6\u00ec\2"+
"\u0a02\u0a05\7\23\2\2\u0a03\u0a05\7\24\2\2\u0a04\u0a01\3\2\2\2\u0a04\u0a02"+
"\3\2\2\2\u0a04\u0a03\3\2\2\2\u0a05\u0161\3\2\2\2\u0a06\u0a0b\5\u01d6\u00ec"+
"\2\u0a07\u0a0b\7\63\2\2\u0a08\u0a0b\7\62\2\2\u0a09\u0a0b\7\4\2\2\u0a0a"+
"\u0a06\3\2\2\2\u0a0a\u0a07\3\2\2\2\u0a0a\u0a08\3\2\2\2\u0a0a\u0a09\3\2"+
"\2\2\u0a0b\u0163\3\2\2\2\u0a0c\u0a17\5\u01d6\u00ec\2\u0a0d\u0a17\7\63"+
"\2\2\u0a0e\u0a17\7\62\2\2\u0a0f\u0a17\7\4\2\2\u0a10\u0a17\7\23\2\2\u0a11"+
"\u0a17\7\24\2\2\u0a12\u0a17\7\17\2\2\u0a13\u0a17\7R\2\2\u0a14\u0a17\7"+
"y\2\2\u0a15\u0a17\7\6\2\2\u0a16\u0a0c\3\2\2\2\u0a16\u0a0d\3\2\2\2\u0a16"+
"\u0a0e\3\2\2\2\u0a16\u0a0f\3\2\2\2\u0a16\u0a10\3\2\2\2\u0a16\u0a11\3\2"+
"\2\2\u0a16\u0a12\3\2\2\2\u0a16\u0a13\3\2\2\2\u0a16\u0a14\3\2\2\2\u0a16"+
"\u0a15\3\2\2\2\u0a17\u0165\3\2\2\2\u0a18\u0a1a\t\t\2\2\u0a19\u0a18\3\2"+
"\2\2\u0a19\u0a1a\3\2\2\2\u0a1a\u0a1b\3\2\2\2\u0a1b\u0a20\5\u0168\u00b5"+
"\2\u0a1c\u0a1d\7\u0099\2\2\u0a1d\u0a1f\5\u0168\u00b5\2\u0a1e\u0a1c\3\2"+
"\2\2\u0a1f\u0a22\3\2\2\2\u0a20\u0a1e\3\2\2\2\u0a20\u0a21\3\2\2\2\u0a21"+
"\u0167\3\2\2\2\u0a22\u0a20\3\2\2\2\u0a23\u0a25\5\16\b\2\u0a24\u0a23\3"+
"\2\2\2\u0a24\u0a25\3\2\2\2\u0a25\u0a26\3\2\2\2\u0a26\u0a27\5\u01a8\u00d5"+
"\2\u0a27\u0169\3\2\2\2\u0a28\u0a29\5\u0138\u009d\2\u0a29\u0a2a\7\13\2"+
"\2\u0a2a\u0a2b\5\u0138\u009d\2\u0a2b\u016b\3\2\2\2\u0a2c\u0a2d\5\u016e"+
"\u00b8\2\u0a2d\u016d\3\2\2\2\u0a2e\u0a32\5\u0172\u00ba\2\u0a2f\u0a31\5"+
"\u0170\u00b9\2\u0a30\u0a2f\3\2\2\2\u0a31\u0a34\3\2\2\2\u0a32\u0a30\3\2"+
"\2\2\u0a32\u0a33\3\2\2\2\u0a33\u016f\3\2\2\2\u0a34\u0a32\3\2\2\2\u0a35"+
"\u0a3b\7\u008d\2\2\u0a36\u0a37\7\u008b\2\2\u0a37\u0a38\5\u0126\u0094\2"+
"\u0a38\u0a39\7\u008c\2\2\u0a39\u0a3b\3\2\2\2\u0a3a\u0a35\3\2\2\2\u0a3a"+
"\u0a36\3\2\2\2\u0a3b\u0a3c\3\2\2\2\u0a3c\u0a3d\5\u0172\u00ba\2\u0a3d\u0171"+
"\3\2\2\2\u0a3e\u0a43\5\u0174\u00bb\2\u0a3f\u0a40\7\n\2\2\u0a40\u0a42\5"+
"\u0174\u00bb\2\u0a41\u0a3f\3\2\2\2\u0a42\u0a45\3\2\2\2\u0a43\u0a41\3\2"+
"\2\2\u0a43\u0a44\3\2\2\2\u0a44\u0173\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a46"+
"\u0a4b\5\u0176\u00bc\2\u0a47\u0a48\7\13\2\2\u0a48\u0a4a\5\u0176\u00bc"+
"\2\u0a49\u0a47\3\2\2\2\u0a4a\u0a4d\3\2\2\2\u0a4b\u0a49\3\2\2\2\u0a4b\u0a4c"+
"\3\2\2\2\u0a4c\u0175\3\2\2\2\u0a4d\u0a4b\3\2\2\2\u0a4e\u0a50\5\u0188\u00c5"+
"\2\u0a4f\u0a4e\3\2\2\2\u0a4f\u0a50\3\2\2\2\u0a50\u0a51\3\2\2\2\u0a51\u0a54"+
"\5\u0178\u00bd\2\u0a52\u0a53\7U\2\2\u0a53\u0a55\5\u0178\u00bd\2\u0a54"+
"\u0a52\3\2\2\2\u0a54\u0a55\3\2\2\2\u0a55\u0177\3\2\2\2\u0a56\u0a5b\7\r"+
"\2\2\u0a57\u0a5b\7\f\2\2\u0a58\u0a59\7\16\2\2\u0a59\u0a5b\5\u017c\u00bf"+
"\2\u0a5a\u0a56\3\2\2\2\u0a5a\u0a57\3\2\2\2\u0a5a\u0a58\3\2\2\2\u0a5b\u0a5d"+
"\3\2\2\2\u0a5c\u0a5e\5\u0188\u00c5\2\u0a5d\u0a5c\3\2\2\2\u0a5d\u0a5e\3"+
"\2\2\2\u0a5e\u0a60\3\2\2\2\u0a5f\u0a5a\3\2\2\2\u0a5f\u0a60\3\2\2\2\u0a60"+
"\u0a61\3\2\2\2\u0a61\u0a62\5\u017a\u00be\2\u0a62\u0179\3\2\2\2\u0a63\u0a69"+
"\5\u0180\u00c1\2\u0a64\u0a65\7\u0092\2\2\u0a65\u0a66\5\u016c\u00b7\2\u0a66"+
"\u0a67\7\u0093\2\2\u0a67\u0a69\3\2\2\2\u0a68\u0a63\3\2\2\2\u0a68\u0a64"+
"\3\2\2\2\u0a69\u0a6e\3\2\2\2\u0a6a\u0a6b\7\17\2\2\u0a6b\u0a6f\5\u0184"+
"\u00c3\2\u0a6c\u0a6d\7{\2\2\u0a6d\u0a6f\5\u0186\u00c4\2\u0a6e\u0a6a\3"+
"\2\2\2\u0a6e\u0a6c\3\2\2\2\u0a6e\u0a6f\3\2\2\2\u0a6f\u017b\3\2\2\2\u0a70"+
"\u0a71\7\u0092\2\2\u0a71\u0a76\5\u017e\u00c0\2\u0a72\u0a73\7\u0099\2\2"+
"\u0a73\u0a75\5\u017e\u00c0\2\u0a74\u0a72\3\2\2\2\u0a75\u0a78\3\2\2\2\u0a76"+
"\u0a74\3\2\2\2\u0a76\u0a77\3\2\2\2\u0a77\u0a79\3\2\2\2\u0a78\u0a76\3\2"+
"\2\2\u0a79\u0a7a\7\u0093\2\2\u0a7a\u017d\3\2\2\2\u0a7b\u0a7c\5\u01b4\u00db"+
"\2\u0a7c\u017f\3\2\2\2\u0a7d\u0a80\5\u0182\u00c2\2\u0a7e\u0a80\5\u019a"+
"\u00ce\2\u0a7f\u0a7d\3\2\2\2\u0a7f\u0a7e\3\2\2\2\u0a80\u0181\3\2\2\2\u0a81"+
"\u0a82\7\u00c5\2\2\u0a82\u0a85\7\u0098\2\2\u0a83\u0a86\7\u00c5\2\2\u0a84"+
"\u0a86\7V\2\2\u0a85\u0a83\3\2\2\2\u0a85\u0a84\3\2\2\2\u0a86\u0a87\3\2"+
"\2\2\u0a87\u0a89\7\u0092\2\2\u0a88\u0a8a\5\u01a6\u00d4\2\u0a89\u0a88\3"+
"\2\2\2\u0a89\u0a8a\3\2\2\2\u0a8a\u0a8b\3\2\2\2\u0a8b\u0a8c\7\u0093\2\2"+
"\u0a8c\u0183\3\2\2\2\u0a8d\u0a8e\7\u00c5\2\2\u0a8e\u0a8f\7\u0098\2\2\u0a8f"+
"\u0a90\7\u00c5\2\2\u0a90\u0a92\7\u0092\2\2\u0a91\u0a93\5\u01b2\u00da\2"+
"\u0a92\u0a91\3\2\2\2\u0a92\u0a93\3\2\2\2\u0a93\u0a94\3\2\2\2\u0a94\u0a95"+
"\7\u0093\2\2\u0a95\u0185\3\2\2\2\u0a96\u0a97\7\u0092\2\2\u0a97\u0a98\5"+
"\u0126\u0094\2\u0a98\u0a99\7\u0093\2\2\u0a99\u0187\3\2\2\2\u0a9a\u0aa4"+
"\7\u0094\2\2\u0a9b\u0aa0\5\u0126\u0094\2\u0a9c\u0a9e\7\u0098\2\2\u0a9d"+
"\u0a9f\5\u0126\u0094\2\u0a9e\u0a9d\3\2\2\2\u0a9e\u0a9f\3\2\2\2\u0a9f\u0aa1"+
"\3\2\2\2\u0aa0\u0a9c\3\2\2\2\u0aa0\u0aa1\3\2\2\2\u0aa1\u0aa5\3\2\2\2\u0aa2"+
"\u0aa3\7\u0098\2\2\u0aa3\u0aa5\5\u0126\u0094\2\u0aa4\u0a9b\3\2\2\2\u0aa4"+
"\u0aa2\3\2\2\2\u0aa5\u0aa6\3\2\2\2\u0aa6\u0aa7\7\u0095\2\2\u0aa7\u0189"+
"\3\2\2\2\u0aa8\u0aa9\7\u00c5\2\2\u0aa9\u0aab\7\u008f\2\2\u0aaa\u0aa8\3"+
"\2\2\2\u0aaa\u0aab\3\2\2\2\u0aab\u0aac\3\2\2\2\u0aac\u0ab2\5\u01a2\u00d2"+
"\2\u0aad\u0aaf\7\u0092\2\2\u0aae\u0ab0\5\u01b0\u00d9\2\u0aaf\u0aae\3\2"+
"\2\2\u0aaf\u0ab0\3\2\2\2\u0ab0\u0ab1\3\2\2\2\u0ab1\u0ab3\7\u0093\2\2\u0ab2"+
"\u0aad\3\2\2\2\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0ab6\5\u018c"+
"\u00c7\2\u0ab5\u0ab4\3\2\2\2\u0ab5\u0ab6\3\2\2\2\u0ab6\u018b\3\2\2\2\u0ab7"+
"\u0abb\5\u018e\u00c8\2\u0ab8\u0aba\5\u018e\u00c8\2\u0ab9\u0ab8\3\2\2\2"+
"\u0aba\u0abd\3\2\2\2\u0abb\u0ab9\3\2\2\2\u0abb\u0abc\3\2\2\2\u0abc\u018d"+
"\3\2\2\2\u0abd\u0abb\3\2\2\2\u0abe\u0ac0\7\u0094\2\2\u0abf\u0ac1\5\u0190"+
"\u00c9\2\u0ac0\u0abf\3\2\2\2\u0ac0\u0ac1\3\2\2\2\u0ac1\u0ac2\3\2\2\2\u0ac2"+
"\u0ac4\5\u0126\u0094\2\u0ac3\u0ac5\5\u0198\u00cd\2\u0ac4\u0ac3\3\2\2\2"+
"\u0ac4\u0ac5\3\2\2\2\u0ac5\u0ac8\3\2\2\2\u0ac6\u0ac7\7\20\2\2\u0ac7\u0ac9"+
"\7\u00c5\2\2\u0ac8\u0ac6\3\2\2\2\u0ac8\u0ac9\3\2\2\2\u0ac9\u0acc\3\2\2"+
"\2\u0aca\u0acb\7\17\2\2\u0acb\u0acd\5\u0126\u0094\2\u0acc\u0aca\3\2\2"+
"\2\u0acc\u0acd\3\2\2\2\u0acd\u0ace\3\2\2\2\u0ace\u0acf\7\u0095\2\2\u0acf"+
"\u018f\3\2\2\2\u0ad0\u0ad1\7\32\2\2\u0ad1\u0ad2\5\u0192\u00ca\2\u0ad2"+
"\u0ad3\7 \2\2\u0ad3\u0191\3\2\2\2\u0ad4\u0ad9\5\u0194\u00cb\2\u0ad5\u0ad6"+
"\7\u0099\2\2\u0ad6\u0ad8\5\u0194\u00cb\2\u0ad7\u0ad5\3\2\2\2\u0ad8\u0adb"+
"\3\2\2\2\u0ad9\u0ad7\3\2\2\2\u0ad9\u0ada\3\2\2\2\u0ada\u0193\3\2\2\2\u0adb"+
"\u0ad9\3\2\2\2\u0adc\u0ae4\7\u00a6\2\2\u0add\u0ae4\5\u0196\u00cc\2\u0ade"+
"\u0ae1\5\u0126\u0094\2\u0adf\u0ae0\7\20\2\2\u0ae0\u0ae2\5\u01d2\u00ea"+
"\2\u0ae1\u0adf\3\2\2\2\u0ae1\u0ae2\3\2\2\2\u0ae2\u0ae4\3\2\2\2\u0ae3\u0adc"+
"\3\2\2\2\u0ae3\u0add\3\2\2\2\u0ae3\u0ade\3\2\2\2\u0ae4\u0195\3\2\2\2\u0ae5"+
"\u0ae6\7\u00c5\2\2\u0ae6\u0ae7\7\u00b7\2\2\u0ae7\u0aea\7\u00a6\2\2\u0ae8"+
"\u0ae9\7\20\2\2\u0ae9\u0aeb\7\u00c5\2\2\u0aea\u0ae8\3\2\2\2\u0aea\u0aeb"+
"\3\2\2\2\u0aeb\u0197\3\2\2\2\u0aec\u0aed\7\u00bd\2\2\u0aed\u0aee\7\u00c5"+
"\2\2\u0aee\u0aef\7\u0092\2\2\u0aef\u0af0\7\u00c5\2\2\u0af0\u0af1\7\u0093"+
"\2\2\u0af1\u0199\3\2\2\2\u0af2\u0af3\7\u00c5\2\2\u0af3\u0af5\7\u008f\2"+
"\2\u0af4\u0af2\3\2\2\2\u0af4\u0af5\3\2\2\2\u0af5\u0af6\3\2\2\2\u0af6\u0afc"+
"\5\u01a2\u00d2\2\u0af7\u0af9\7\u0092\2\2\u0af8\u0afa\5\u01b0\u00d9\2\u0af9"+
"\u0af8\3\2\2\2\u0af9\u0afa\3\2\2\2\u0afa\u0afb\3\2\2\2\u0afb\u0afd\7\u0093"+
"\2\2\u0afc\u0af7\3\2\2\2\u0afc\u0afd\3\2\2\2\u0afd\u0aff\3\2\2\2\u0afe"+
"\u0b00\5\u018c\u00c7\2\u0aff\u0afe\3\2\2\2\u0aff\u0b00\3\2\2\2\u0b00\u0b02"+
"\3\2\2\2\u0b01\u0b03\5\u019c\u00cf\2\u0b02\u0b01\3\2\2\2\u0b02\u0b03\3"+
"\2\2\2\u0b03\u019b\3\2\2\2\u0b04\u0b05\7\u00bd\2\2\u0b05\u0b0a\7\u00c5"+
"\2\2\u0b06\u0b07\7\u0092\2\2\u0b07\u0b08\5\u01ec\u00f7\2\u0b08\u0b09\7"+
"\u0093\2\2\u0b09\u0b0b\3\2\2\2\u0b0a\u0b06\3\2\2\2\u0b0a\u0b0b\3\2\2\2"+
"\u0b0b\u019d\3\2\2\2\u0b0c\u0b10\5\u01a2\u00d2\2\u0b0d\u0b0f\5\u01a0\u00d1"+
"\2\u0b0e\u0b0d\3\2\2\2\u0b0f\u0b12\3\2\2\2\u0b10\u0b0e\3\2\2\2\u0b10\u0b11"+
"\3\2\2\2\u0b11\u019f\3\2\2\2\u0b12\u0b10\3\2\2\2\u0b13\u0b15\7\u0094\2"+
"\2\u0b14\u0b16\7\u00c5\2\2\u0b15\u0b14\3\2\2\2\u0b15\u0b16\3\2\2\2\u0b16"+
"\u0b17\3\2\2\2\u0b17\u0b18\7\u0095\2\2\u0b18\u01a1\3\2\2\2\u0b19\u0b1e"+
"\5\u01d4\u00eb\2\u0b1a\u0b1b\7\u00b7\2\2\u0b1b\u0b1d\5\u01d4\u00eb\2\u0b1c"+
"\u0b1a\3\2\2\2\u0b1d\u0b20\3\2\2\2\u0b1e\u0b1c\3\2\2\2\u0b1e\u0b1f\3\2"+
"\2\2\u0b1f\u01a3\3\2\2\2\u0b20\u0b1e\3\2\2\2\u0b21\u0b26\5\u01a8\u00d5"+
"\2\u0b22\u0b23\7\u0099\2\2\u0b23\u0b25\5\u01a8\u00d5\2\u0b24\u0b22\3\2"+
"\2\2\u0b25\u0b28\3\2\2\2\u0b26\u0b24\3\2\2\2\u0b26\u0b27\3\2\2\2\u0b27"+
"\u01a5\3\2\2\2\u0b28\u0b26\3\2\2\2\u0b29\u0b2e\5\u01aa\u00d6\2\u0b2a\u0b2b"+
"\7\u0099\2\2\u0b2b\u0b2d\5\u01aa\u00d6\2\u0b2c\u0b2a\3\2\2\2\u0b2d\u0b30"+
"\3\2\2\2\u0b2e\u0b2c\3\2\2\2\u0b2e\u0b2f\3\2\2\2\u0b2f\u01a7\3\2\2\2\u0b30"+
"\u0b2e\3\2\2\2\u0b31\u0b34\5\u01ac\u00d7\2\u0b32\u0b34\5\u01b4\u00db\2"+
"\u0b33\u0b31\3\2\2\2\u0b33\u0b32\3\2\2\2\u0b34\u01a9\3\2\2\2\u0b35\u0b38"+
"\5\u01ae\u00d8\2\u0b36\u0b38\5\u01b6\u00dc\2\u0b37\u0b35\3\2\2\2\u0b37"+
"\u0b36\3\2\2\2\u0b38\u01ab\3\2\2\2\u0b39\u0b3a\7\u00c5\2\2\u0b3a\u0b41"+
"\7\u0098\2\2\u0b3b\u0b42\5\u0126\u0094\2\u0b3c\u0b3e\7\u0092\2\2\u0b3d"+
"\u0b3f\5\u01b0\u00d9\2\u0b3e\u0b3d\3\2\2\2\u0b3e\u0b3f\3\2\2\2\u0b3f\u0b40"+
"\3\2\2\2\u0b40\u0b42\7\u0093\2\2\u0b41\u0b3b\3\2\2\2\u0b41\u0b3c\3\2\2"+
"\2\u0b42\u01ad\3\2\2\2\u0b43\u0b44\7\u00c5\2\2\u0b44\u0b4b\7\u0098\2\2"+
"\u0b45\u0b4c\5\u01b4\u00db\2\u0b46\u0b48\7\u0092\2\2\u0b47\u0b49\5\u01b2"+
"\u00da\2\u0b48\u0b47\3\2\2\2\u0b48\u0b49\3\2\2\2\u0b49\u0b4a\3\2\2\2\u0b4a"+
"\u0b4c\7\u0093\2\2\u0b4b\u0b45\3\2\2\2\u0b4b\u0b46\3\2\2\2\u0b4c\u01af"+
"\3\2\2\2\u0b4d\u0b52\5\u0126\u0094\2\u0b4e\u0b4f\7\u0099\2\2\u0b4f\u0b51"+
"\5\u0126\u0094\2\u0b50\u0b4e\3\2\2\2\u0b51\u0b54\3\2\2\2\u0b52\u0b50\3"+
"\2\2\2\u0b52\u0b53\3\2\2\2\u0b53\u01b1\3\2\2\2\u0b54\u0b52\3\2\2\2\u0b55"+
"\u0b5a\5\u01b6\u00dc\2\u0b56\u0b57\7\u0099\2\2\u0b57\u0b59\5\u01b6\u00dc"+
"\2\u0b58\u0b56\3\2\2\2\u0b59\u0b5c\3\2\2\2\u0b5a\u0b58\3\2\2\2\u0b5a\u0b5b"+
"\3\2\2\2\u0b5b\u01b3\3\2\2\2\u0b5c\u0b5a\3\2\2\2\u0b5d\u0b68\5\u01ba\u00de"+
"\2\u0b5e\u0b68\5\u01d8\u00ed\2\u0b5f\u0b68\5\u01b8\u00dd\2\u0b60\u0b68"+
"\5\u01c0\u00e1\2\u0b61\u0b68\5\u01be\u00e0\2\u0b62\u0b68\5\u01c2\u00e2"+
"\2\u0b63\u0b68\5\u01c4\u00e3\2\u0b64\u0b68\5\u01c6\u00e4\2\u0b65\u0b68"+
"\7\u00a6\2\2\u0b66\u0b68\5\u0196\u00cc\2\u0b67\u0b5d\3\2\2\2\u0b67\u0b5e"+
"\3\2\2\2\u0b67\u0b5f\3\2\2\2\u0b67\u0b60\3\2\2\2\u0b67\u0b61\3\2\2\2\u0b67"+
"\u0b62\3\2\2\2\u0b67\u0b63\3\2\2\2\u0b67\u0b64\3\2\2\2\u0b67\u0b65\3\2"+
"\2\2\u0b67\u0b66\3\2\2\2\u0b68\u01b5\3\2\2\2\u0b69\u0b6c\5\u01bc\u00df"+
"\2\u0b6a\u0b6c\5\u01b4\u00db\2\u0b6b\u0b69\3\2\2\2\u0b6b\u0b6a\3\2\2\2"+
"\u0b6c\u01b7\3\2\2\2\u0b6d\u0b73\5\u0126\u0094\2\u0b6e\u0b74\78\2\2\u0b6f"+
"\u0b74\79\2\2\u0b70\u0b74\7f\2\2\u0b71\u0b74\7e\2\2\u0b72\u0b74\7d\2\2"+
"\u0b73\u0b6e\3\2\2\2\u0b73\u0b6f\3\2\2\2\u0b73\u0b70\3\2\2\2\u0b73\u0b71"+
"\3\2\2\2\u0b73\u0b72\3\2\2\2\u0b73\u0b74\3\2\2\2\u0b74\u01b9\3\2\2\2\u0b75"+
"\u0b76\7K\2\2\u0b76\u01bb\3\2\2\2\u0b77\u0b78\7\63\2\2\u0b78\u01bd\3\2"+
"\2\2\u0b79\u0b7a\7\u00a6\2\2\u0b7a\u0b7e\7\u009e\2\2\u0b7b\u0b7f\5\u01ec"+
"\u00f7\2\u0b7c\u0b7f\7\u00c5\2\2\u0b7d\u0b7f\5\u01ee\u00f8\2\u0b7e\u0b7b"+
"\3\2\2\2\u0b7e\u0b7c\3\2\2\2\u0b7e\u0b7d\3\2\2\2\u0b7f\u01bf\3\2\2\2\u0b80"+
"\u0b84\5\u01ec\u00f7\2\u0b81\u0b84\7\u00c5\2\2\u0b82\u0b84\5\u01ee\u00f8"+
"\2\u0b83\u0b80\3\2\2\2\u0b83\u0b81\3\2\2\2\u0b83\u0b82\3\2\2\2\u0b84\u0b85"+
"\3\2\2\2\u0b85\u0b89\7\u0098\2\2\u0b86\u0b8a\5\u01ec\u00f7\2\u0b87\u0b8a"+
"\7\u00c5\2\2\u0b88\u0b8a\5\u01ee\u00f8\2\u0b89\u0b86\3\2\2\2\u0b89\u0b87"+
"\3\2\2\2\u0b89\u0b88\3\2\2\2\u0b8a\u01c1\3\2\2\2\u0b8b\u0b8f\5\u01ec\u00f7"+
"\2\u0b8c\u0b8f\7\u00c5\2\2\u0b8d\u0b8f\5\u01ee\u00f8\2\u0b8e\u0b8b\3\2"+
"\2\2\u0b8e\u0b8c\3\2\2\2\u0b8e\u0b8d\3\2\2\2\u0b8f\u0b90\3\2\2\2\u0b90"+
"\u0b91\7\63\2\2\u0b91\u01c3\3\2\2\2\u0b92\u0b96\5\u01ec\u00f7\2\u0b93"+
"\u0b96\7\u00c5\2\2\u0b94\u0b96\5\u01ee\u00f8\2\u0b95\u0b92\3\2\2\2\u0b95"+
"\u0b93\3\2\2\2\u0b95\u0b94\3\2\2\2\u0b96\u0b97\3\2\2\2\u0b97\u0b98\7J"+
"\2\2\u0b98\u01c5\3\2\2\2\u0b99\u0b9a\7\u0094\2\2\u0b9a\u0b9f\5\u01c8\u00e5"+
"\2\u0b9b\u0b9c\7\u0099\2\2\u0b9c\u0b9e\5\u01c8\u00e5\2\u0b9d\u0b9b\3\2"+
"\2\2\u0b9e\u0ba1\3\2\2\2\u0b9f\u0b9d\3\2\2\2\u0b9f\u0ba0\3\2\2\2\u0ba0"+
"\u0ba2\3\2\2\2\u0ba1\u0b9f\3\2\2\2\u0ba2\u0ba3\7\u0095\2\2\u0ba3\u01c7"+
"\3\2\2\2\u0ba4\u0ba8\5\u01c0\u00e1\2\u0ba5\u0ba8\5\u01be\u00e0\2\u0ba6"+
"\u0ba8\5\u01f4\u00fb\2\u0ba7\u0ba4\3\2\2\2\u0ba7\u0ba5\3\2\2\2\u0ba7\u0ba6"+
"\3\2\2\2\u0ba8\u01c9\3\2\2\2\u0ba9\u0bae\5\u01cc\u00e7\2\u0baa\u0bab\7"+
"\u00b7\2\2\u0bab\u0bad\5\u01cc\u00e7\2\u0bac\u0baa\3\2\2\2\u0bad\u0bb0"+
"\3\2\2\2\u0bae\u0bac\3\2\2\2\u0bae\u0baf\3\2\2\2\u0baf\u01cb\3\2\2\2\u0bb0"+
"\u0bae\3\2\2\2\u0bb1\u0bc2\5\u01ce\u00e8\2\u0bb2\u0bb3\7\u0094\2\2\u0bb3"+
"\u0bb4\5\u01ec\u00f7\2\u0bb4\u0bb6\7\u0095\2\2\u0bb5\u0bb7\7\u0091\2\2"+
"\u0bb6\u0bb5\3\2\2\2\u0bb6\u0bb7\3\2\2\2\u0bb7\u0bc3\3\2\2\2\u0bb8\u0bbb"+
"\7\u0092\2\2\u0bb9\u0bbc\7\u00c4\2\2\u0bba\u0bbc\7\u00c3\2\2\u0bbb\u0bb9"+
"\3\2\2\2\u0bbb\u0bba\3\2\2\2\u0bbc\u0bbd\3\2\2\2\u0bbd\u0bbf\7\u0093\2"+
"\2\u0bbe\u0bc0\7\u0091\2\2\u0bbf\u0bbe\3\2\2\2\u0bbf\u0bc0\3\2\2\2\u0bc0"+
"\u0bc3\3\2\2\2\u0bc1\u0bc3\7\u0091\2\2\u0bc2\u0bb2\3\2\2\2\u0bc2\u0bb8"+
"\3\2\2\2\u0bc2\u0bc1\3\2\2\2\u0bc2\u0bc3\3\2\2\2\u0bc3\u01cd\3\2\2\2\u0bc4"+
"\u0bcc\5\u01d2\u00ea\2\u0bc5\u0bc6\7\u00bb\2\2\u0bc6\u0bc8\7\u00b7\2\2"+
"\u0bc7\u0bc9\5\u01d2\u00ea\2\u0bc8\u0bc7\3\2\2\2\u0bc8\u0bc9\3\2\2\2\u0bc9"+
"\u0bcb\3\2\2\2\u0bca\u0bc5\3\2\2\2\u0bcb\u0bce\3\2\2\2\u0bcc\u0bca\3\2"+
"\2\2\u0bcc\u0bcd\3\2\2\2\u0bcd\u01cf\3\2\2\2\u0bce\u0bcc\3\2\2\2\u0bcf"+
"\u0bd2\7\u00c5\2\2\u0bd0\u0bd2\7\u00c2\2\2\u0bd1\u0bcf\3\2\2\2\u0bd1\u0bd0"+
"\3\2\2\2\u0bd2\u01d1\3\2\2\2\u0bd3\u0c08\7\u00c5\2\2\u0bd4\u0c08\7\u00c2"+
"\2\2\u0bd5\u0c08\7V\2\2\u0bd6\u0c08\7\31\2\2\u0bd7\u0c08\7\t\2\2\u0bd8"+
"\u0c08\7\r\2\2\u0bd9\u0c08\7=\2\2\u0bda\u0c08\7\21\2\2\u0bdb\u0c08\7\22"+
"\2\2\u0bdc\u0c08\7\23\2\2\u0bdd\u0c08\7\24\2\2\u0bde\u0c08\7\25\2\2\u0bdf"+
"\u0c08\7\26\2\2\u0be0\u0c08\7\27\2\2\u0be1\u0c08\7\30\2\2\u0be2\u0c08"+
"\7\61\2\2\u0be3\u0c08\7\62\2\2\u0be4\u0c08\7\63\2\2\u0be5\u0c08\7{\2\2"+
"\u0be6\u0c08\7}\2\2\u0be7\u0c08\7~\2\2\u0be8\u0c08\7>\2\2\u0be9\u0c08"+
"\7?\2\2\u0bea\u0c08\7@\2\2\u0beb\u0c08\7U\2\2\u0bec\u0c08\7A\2\2\u0bed"+
"\u0c08\7B\2\2\u0bee\u0c08\7C\2\2\u0bef\u0c08\7D\2\2\u0bf0\u0c08\7E\2\2"+
"\u0bf1\u0c08\7H\2\2\u0bf2\u0c08\7J\2\2\u0bf3\u0c08\7K\2\2\u0bf4\u0c08"+
"\7L\2\2\u0bf5\u0c08\7M\2\2\u0bf6\u0c08\7N\2\2\u0bf7\u0c08\7Q\2\2\u0bf8"+
"\u0c08\7S\2\2\u0bf9\u0c08\7T\2\2\u0bfa\u0c08\7W\2\2\u0bfb\u0c08\7\4\2"+
"\2\u0bfc\u0c08\7$\2\2\u0bfd\u0c08\7%\2\2\u0bfe\u0c08\7!\2\2\u0bff\u0c08"+
"\7&\2\2\u0c00\u0c08\7#\2\2\u0c01\u0c08\7v\2\2\u0c02\u0c08\7w\2\2\u0c03"+
"\u0c08\7x\2\2\u0c04\u0c08\7\u0082\2\2\u0c05\u0c08\7z\2\2\u0c06\u0c08\7"+
"|\2\2\u0c07\u0bd3\3\2\2\2\u0c07\u0bd4\3\2\2\2\u0c07\u0bd5\3\2\2\2\u0c07"+
"\u0bd6\3\2\2\2\u0c07\u0bd7\3\2\2\2\u0c07\u0bd8\3\2\2\2\u0c07\u0bd9\3\2"+
"\2\2\u0c07\u0bda\3\2\2\2\u0c07\u0bdb\3\2\2\2\u0c07\u0bdc\3\2\2\2\u0c07"+
"\u0bdd\3\2\2\2\u0c07\u0bde\3\2\2\2\u0c07\u0bdf\3\2\2\2\u0c07\u0be0\3\2"+
"\2\2\u0c07\u0be1\3\2\2\2\u0c07\u0be2\3\2\2\2\u0c07\u0be3\3\2\2\2\u0c07"+
"\u0be4\3\2\2\2\u0c07\u0be5\3\2\2\2\u0c07\u0be6\3\2\2\2\u0c07\u0be7\3\2"+
"\2\2\u0c07\u0be8\3\2\2\2\u0c07\u0be9\3\2\2\2\u0c07\u0bea\3\2\2\2\u0c07"+
"\u0beb\3\2\2\2\u0c07\u0bec\3\2\2\2\u0c07\u0bed\3\2\2\2\u0c07\u0bee\3\2"+
"\2\2\u0c07\u0bef\3\2\2\2\u0c07\u0bf0\3\2\2\2\u0c07\u0bf1\3\2\2\2\u0c07"+
"\u0bf2\3\2\2\2\u0c07\u0bf3\3\2\2\2\u0c07\u0bf4\3\2\2\2\u0c07\u0bf5\3\2"+
"\2\2\u0c07\u0bf6\3\2\2\2\u0c07\u0bf7\3\2\2\2\u0c07\u0bf8\3\2\2\2\u0c07"+
"\u0bf9\3\2\2\2\u0c07\u0bfa\3\2\2\2\u0c07\u0bfb\3\2\2\2\u0c07\u0bfc\3\2"+
"\2\2\u0c07\u0bfd\3\2\2\2\u0c07\u0bfe\3\2\2\2\u0c07\u0bff\3\2\2\2\u0c07"+
"\u0c00\3\2\2\2\u0c07\u0c01\3\2\2\2\u0c07\u0c02\3\2\2\2\u0c07\u0c03\3\2"+
"\2\2\u0c07\u0c04\3\2\2\2\u0c07\u0c05\3\2\2\2\u0c07\u0c06\3\2\2\2\u0c08"+
"\u01d3\3\2\2\2\u0c09\u0c0d\7\u00c5\2\2\u0c0a\u0c0d\7\61\2\2\u0c0b\u0c0d"+
"\7\u00c2\2\2\u0c0c\u0c09\3\2\2\2\u0c0c\u0c0a\3\2\2\2\u0c0c\u0c0b\3\2\2"+
"\2\u0c0d\u01d5\3\2\2\2\u0c0e\u0c11\7\u00c5\2\2\u0c0f\u0c11\7\u00c2\2\2"+
"\u0c10\u0c0e\3\2\2\2\u0c10\u0c0f\3\2\2\2\u0c11\u01d7\3\2\2\2\u0c12\u0c14"+
"\5\u01da\u00ee\2\u0c13\u0c15\5\u01dc\u00ef\2\u0c14\u0c13\3\2\2\2\u0c14"+
"\u0c15\3\2\2\2\u0c15\u0c17\3\2\2\2\u0c16\u0c18\5\u01de\u00f0\2\u0c17\u0c16"+
"\3\2\2\2\u0c17\u0c18\3\2\2\2\u0c18\u0c1a\3\2\2\2\u0c19\u0c1b\5\u01e0\u00f1"+
"\2\u0c1a\u0c19\3\2\2\2\u0c1a\u0c1b\3\2\2\2\u0c1b\u0c1d\3\2\2\2\u0c1c\u0c1e"+
"\5\u01e2\u00f2\2\u0c1d\u0c1c\3\2\2\2\u0c1d\u0c1e\3\2\2\2\u0c1e\u0c20\3"+
"\2\2\2\u0c1f\u0c21\5\u01e4\u00f3\2\u0c20\u0c1f\3\2\2\2\u0c20\u0c21\3\2"+
"\2\2\u0c21\u0c23\3\2\2\2\u0c22\u0c24\5\u01e6\u00f4\2\u0c23\u0c22\3\2\2"+
"\2\u0c23\u0c24\3\2\2\2\u0c24\u0c26\3\2\2\2\u0c25\u0c27\5\u01e8\u00f5\2"+
"\u0c26\u0c25\3\2\2\2\u0c26\u0c27\3\2\2\2\u0c27\u0c29\3\2\2\2\u0c28\u0c2a"+
"\5\u01ea\u00f6\2\u0c29\u0c28\3\2\2\2\u0c29\u0c2a\3\2\2\2\u0c2a\u0c88\3"+
"\2\2\2\u0c2b\u0c2d\5\u01dc\u00ef\2\u0c2c\u0c2e\5\u01de\u00f0\2\u0c2d\u0c2c"+
"\3\2\2\2\u0c2d\u0c2e\3\2\2\2\u0c2e\u0c30\3\2\2\2\u0c2f\u0c31\5\u01e0\u00f1"+
"\2\u0c30\u0c2f\3\2\2\2\u0c30\u0c31\3\2\2\2\u0c31\u0c33\3\2\2\2\u0c32\u0c34"+
"\5\u01e2\u00f2\2\u0c33\u0c32\3\2\2\2\u0c33\u0c34\3\2\2\2\u0c34\u0c36\3"+
"\2\2\2\u0c35\u0c37\5\u01e4\u00f3\2\u0c36\u0c35\3\2\2\2\u0c36\u0c37\3\2"+
"\2\2\u0c37\u0c39\3\2\2\2\u0c38\u0c3a\5\u01e6\u00f4\2\u0c39\u0c38\3\2\2"+
"\2\u0c39\u0c3a\3\2\2\2\u0c3a\u0c3c\3\2\2\2\u0c3b\u0c3d\5\u01e8\u00f5\2"+
"\u0c3c\u0c3b\3\2\2\2\u0c3c\u0c3d\3\2\2\2\u0c3d\u0c3f\3\2\2\2\u0c3e\u0c40"+
"\5\u01ea\u00f6\2\u0c3f\u0c3e\3\2\2\2\u0c3f\u0c40\3\2\2\2\u0c40\u0c88\3"+
"\2\2\2\u0c41\u0c43\5\u01de\u00f0\2\u0c42\u0c44\5\u01e0\u00f1\2\u0c43\u0c42"+
"\3\2\2\2\u0c43\u0c44\3\2\2\2\u0c44\u0c46\3\2\2\2\u0c45\u0c47\5\u01e2\u00f2"+
"\2\u0c46\u0c45\3\2\2\2\u0c46\u0c47\3\2\2\2\u0c47\u0c49\3\2\2\2\u0c48\u0c4a"+
"\5\u01e4\u00f3\2\u0c49\u0c48\3\2\2\2\u0c49\u0c4a\3\2\2\2\u0c4a\u0c4c\3"+
"\2\2\2\u0c4b\u0c4d\5\u01e6\u00f4\2\u0c4c\u0c4b\3\2\2\2\u0c4c\u0c4d\3\2"+
"\2\2\u0c4d\u0c4f\3\2\2\2\u0c4e\u0c50\5\u01e8\u00f5\2\u0c4f\u0c4e\3\2\2"+
"\2\u0c4f\u0c50\3\2\2\2\u0c50\u0c52\3\2\2\2\u0c51\u0c53\5\u01ea\u00f6\2"+
"\u0c52\u0c51\3\2\2\2\u0c52\u0c53\3\2\2\2\u0c53\u0c88\3\2\2\2\u0c54\u0c56"+
"\5\u01e0\u00f1\2\u0c55\u0c57\5\u01e2\u00f2\2\u0c56\u0c55\3\2\2\2\u0c56"+
"\u0c57\3\2\2\2\u0c57\u0c59\3\2\2\2\u0c58\u0c5a\5\u01e4\u00f3\2\u0c59\u0c58"+
"\3\2\2\2\u0c59\u0c5a\3\2\2\2\u0c5a\u0c5c\3\2\2\2\u0c5b\u0c5d\5\u01e6\u00f4"+
"\2\u0c5c\u0c5b\3\2\2\2\u0c5c\u0c5d\3\2\2\2\u0c5d\u0c5f\3\2\2\2\u0c5e\u0c60"+
"\5\u01e8\u00f5\2\u0c5f\u0c5e\3\2\2\2\u0c5f\u0c60\3\2\2\2\u0c60\u0c62\3"+
"\2\2\2\u0c61\u0c63\5\u01ea\u00f6\2\u0c62\u0c61\3\2\2\2\u0c62\u0c63\3\2"+
"\2\2\u0c63\u0c88\3\2\2\2\u0c64\u0c66\5\u01e2\u00f2\2\u0c65\u0c67\5\u01e4"+
"\u00f3\2\u0c66\u0c65\3\2\2\2\u0c66\u0c67\3\2\2\2\u0c67\u0c69\3\2\2\2\u0c68"+
"\u0c6a\5\u01e6\u00f4\2\u0c69\u0c68\3\2\2\2\u0c69\u0c6a\3\2\2\2\u0c6a\u0c6c"+
"\3\2\2\2\u0c6b\u0c6d\5\u01e8\u00f5\2\u0c6c\u0c6b\3\2\2\2\u0c6c\u0c6d\3"+
"\2\2\2\u0c6d\u0c6f\3\2\2\2\u0c6e\u0c70\5\u01ea\u00f6\2\u0c6f\u0c6e\3\2"+
"\2\2\u0c6f\u0c70\3\2\2\2\u0c70\u0c88\3\2\2\2\u0c71\u0c73\5\u01e4\u00f3"+
"\2\u0c72\u0c74\5\u01e6\u00f4\2\u0c73\u0c72\3\2\2\2\u0c73\u0c74\3\2\2\2"+
"\u0c74\u0c76\3\2\2\2\u0c75\u0c77\5\u01e8\u00f5\2\u0c76\u0c75\3\2\2\2\u0c76"+
"\u0c77\3\2\2\2\u0c77\u0c79\3\2\2\2\u0c78\u0c7a\5\u01ea\u00f6\2\u0c79\u0c78"+
"\3\2\2\2\u0c79\u0c7a\3\2\2\2\u0c7a\u0c88\3\2\2\2\u0c7b\u0c7d\5\u01e6\u00f4"+
"\2\u0c7c\u0c7e\5\u01e8\u00f5\2\u0c7d\u0c7c\3\2\2\2\u0c7d\u0c7e\3\2\2\2"+
"\u0c7e\u0c80\3\2\2\2\u0c7f\u0c81\5\u01ea\u00f6\2\u0c80\u0c7f\3\2\2\2\u0c80"+
"\u0c81\3\2\2\2\u0c81\u0c88\3\2\2\2\u0c82\u0c84\5\u01e8\u00f5\2\u0c83\u0c85"+
"\5\u01ea\u00f6\2\u0c84\u0c83\3\2\2\2\u0c84\u0c85\3\2\2\2\u0c85\u0c88\3"+
"\2\2\2\u0c86\u0c88\5\u01ea\u00f6\2\u0c87\u0c12\3\2\2\2\u0c87\u0c2b\3\2"+
"\2\2\u0c87\u0c41\3\2\2\2\u0c87\u0c54\3\2\2\2\u0c87\u0c64\3\2\2\2\u0c87"+
"\u0c71\3\2\2\2\u0c87\u0c7b\3\2\2\2\u0c87\u0c82\3\2\2\2\u0c87\u0c86\3\2"+
"\2\2\u0c88\u01d9\3\2\2\2\u0c89\u0c8d\5\u01f4\u00fb\2\u0c8a\u0c8d\7\u00c5"+
"\2\2\u0c8b\u0c8d\5\u01ee\u00f8\2\u0c8c\u0c89\3\2\2\2\u0c8c\u0c8a\3\2\2"+
"\2\u0c8c\u0c8b\3\2\2\2\u0c8d\u0c8e\3\2\2\2\u0c8e\u0c8f\t\13\2\2\u0c8f"+
"\u01db\3\2\2\2\u0c90\u0c94\5\u01f4\u00fb\2\u0c91\u0c94\7\u00c5\2\2\u0c92"+
"\u0c94\5\u01ee\u00f8\2\u0c93\u0c90\3\2\2\2\u0c93\u0c91\3\2\2\2\u0c93\u0c92"+
"\3\2\2\2\u0c94\u0c95\3\2\2\2\u0c95\u0c96\t\f\2\2\u0c96\u01dd\3\2\2\2\u0c97"+
"\u0c9b\5\u01f4\u00fb\2\u0c98\u0c9b\7\u00c5\2\2\u0c99\u0c9b\5\u01ee\u00f8"+
"\2\u0c9a\u0c97\3\2\2\2\u0c9a\u0c98\3\2\2\2\u0c9a\u0c99\3\2\2\2\u0c9b\u0c9c"+
"\3\2\2\2\u0c9c\u0c9d\t\r\2\2\u0c9d\u01df\3\2\2\2\u0c9e\u0ca2\5\u01f4\u00fb"+
"\2\u0c9f\u0ca2\7\u00c5\2\2\u0ca0\u0ca2\5\u01ee\u00f8\2\u0ca1\u0c9e\3\2"+
"\2\2\u0ca1\u0c9f\3\2\2\2\u0ca1\u0ca0\3\2\2\2\u0ca2\u0ca3\3\2\2\2\u0ca3"+
"\u0ca4\t\16\2\2\u0ca4\u01e1\3\2\2\2\u0ca5\u0ca9\5\u01f4\u00fb\2\u0ca6"+
"\u0ca9\7\u00c5\2\2\u0ca7\u0ca9\5\u01ee\u00f8\2\u0ca8\u0ca5\3\2\2\2\u0ca8"+
"\u0ca6\3\2\2\2\u0ca8\u0ca7\3\2\2\2\u0ca9\u0caa\3\2\2\2\u0caa\u0cab\t\17"+
"\2\2\u0cab\u01e3\3\2\2\2\u0cac\u0cb0\5\u01f4\u00fb\2\u0cad\u0cb0\7\u00c5"+
"\2\2\u0cae\u0cb0\5\u01ee\u00f8\2\u0caf\u0cac\3\2\2\2\u0caf\u0cad\3\2\2"+
"\2\u0caf\u0cae\3\2\2\2\u0cb0\u0cb1\3\2\2\2\u0cb1\u0cb2\t\20\2\2\u0cb2"+
"\u01e5\3\2\2\2\u0cb3\u0cb7\5\u01f4\u00fb\2\u0cb4\u0cb7\7\u00c5\2\2\u0cb5"+
"\u0cb7\5\u01ee\u00f8\2\u0cb6\u0cb3\3\2\2\2\u0cb6\u0cb4\3\2\2\2\u0cb6\u0cb5"+
"\3\2\2\2\u0cb7\u0cb8\3\2\2\2\u0cb8\u0cb9\t\21\2\2\u0cb9\u01e7\3\2\2\2"+
"\u0cba\u0cbe\5\u01f4\u00fb\2\u0cbb\u0cbe\7\u00c5\2\2\u0cbc\u0cbe\5\u01ee"+
"\u00f8\2\u0cbd\u0cba\3\2\2\2\u0cbd\u0cbb\3\2\2\2\u0cbd\u0cbc\3\2\2\2\u0cbe"+
"\u0cbf\3\2\2\2\u0cbf\u0cc0\t\22\2\2\u0cc0\u01e9\3\2\2\2\u0cc1\u0cc5\5"+
"\u01f4\u00fb\2\u0cc2\u0cc5\7\u00c5\2\2\u0cc3\u0cc5\5\u01ee\u00f8\2\u0cc4"+
"\u0cc1\3\2\2\2\u0cc4\u0cc2\3\2\2\2\u0cc4\u0cc3\3\2\2\2\u0cc5\u0cc6\3\2"+
"\2\2\u0cc6\u0cc7\t\23\2\2\u0cc7\u01eb\3\2\2\2\u0cc8\u0cc9\t\24\2\2\u0cc9"+
"\u01ed\3\2\2\2\u0cca\u0cd3\7\u0091\2\2\u0ccb\u0ccd\7\u0098\2\2\u0ccc\u0cce"+
"\5\u01f0\u00f9\2\u0ccd\u0ccc\3\2\2\2\u0ccd\u0cce\3\2\2\2\u0cce\u0cd1\3"+
"\2\2\2\u0ccf\u0cd0\7\u0098\2\2\u0cd0\u0cd2\5\u019e\u00d0\2\u0cd1\u0ccf"+
"\3\2\2\2\u0cd1\u0cd2\3\2\2\2\u0cd2\u0cd4\3\2\2\2\u0cd3\u0ccb\3\2\2\2\u0cd3"+
"\u0cd4\3\2\2\2\u0cd4\u01ef\3\2\2\2\u0cd5\u0cd7\7\u009e\2\2\u0cd6\u0cd5"+
"\3\2\2\2\u0cd6\u0cd7\3\2\2\2\u0cd7\u0cd8\3\2\2\2\u0cd8\u0cdd\5\u01d4\u00eb"+
"\2\u0cd9\u0cda\7\u009e\2\2\u0cda\u0cdc\5\u01d4\u00eb\2\u0cdb\u0cd9\3\2"+
"\2\2\u0cdc\u0cdf\3\2\2\2\u0cdd\u0cdb\3\2\2\2\u0cdd\u0cde\3\2\2\2\u0cde"+
"\u01f1\3\2\2\2\u0cdf\u0cdd\3\2\2\2\u0ce0\u0ce6\5\u01f4\u00fb\2\u0ce1\u0ce6"+
"\5\u01f6\u00fc\2\u0ce2\u0ce6\7m\2\2\u0ce3\u0ce6\7n\2\2\u0ce4\u0ce6\7o"+
"\2\2\u0ce5\u0ce0\3\2\2\2\u0ce5\u0ce1\3\2\2\2\u0ce5\u0ce2\3\2\2\2\u0ce5"+
"\u0ce3\3\2\2\2\u0ce5\u0ce4\3\2\2\2\u0ce6\u01f3\3\2\2\2\u0ce7\u0cea\7\u00a3"+
"\2\2\u0ce8\u0cea\7\u00a0\2\2\u0ce9\u0ce7\3\2\2\2\u0ce9\u0ce8\3\2\2\2\u0ce9"+
"\u0cea\3\2\2\2\u0cea\u0ceb\3\2\2\2\u0ceb\u0cec\5\u01ec\u00f7\2\u0cec\u01f5"+
"\3\2\2\2\u0ced\u0cf0\7\u00c4\2\2\u0cee\u0cf0\7\u00c3\2\2\u0cef\u0ced\3"+
"\2\2\2\u0cef\u0cee\3\2\2\2\u0cf0\u01f7\3\2\2\2\u0cf1\u0cf5\5\u01f2\u00fa"+
"\2\u0cf2\u0cf5\5\u01fa\u00fe\2\u0cf3\u0cf5\5\u01fc\u00ff\2\u0cf4\u0cf1"+
"\3\2\2\2\u0cf4\u0cf2\3\2\2\2\u0cf4\u0cf3\3\2\2\2\u0cf5\u01f9\3\2\2\2\u0cf6"+
"\u0cf7\7\u0096\2\2\u0cf7\u0cf8\5\u0200\u0101\2\u0cf8\u0cf9\7\u0097\2\2"+
"\u0cf9\u01fb\3\2\2\2\u0cfa\u0cfc\7\u0094\2\2\u0cfb\u0cfd\5\u01fe\u0100"+
"\2\u0cfc\u0cfb\3\2\2\2\u0cfc\u0cfd\3\2\2\2\u0cfd\u0cfe\3\2\2\2\u0cfe\u0cff"+
"\7\u0095\2\2\u0cff\u01fd\3\2\2\2\u0d00\u0d05\5\u01f8\u00fd\2\u0d01\u0d02"+
"\7\u0099\2\2\u0d02\u0d04\5\u01f8\u00fd\2\u0d03\u0d01\3\2\2\2\u0d04\u0d07"+
"\3\2\2\2\u0d05\u0d03\3\2\2\2\u0d05\u0d06\3\2\2\2\u0d06\u0d09\3\2\2\2\u0d07"+
"\u0d05\3\2\2\2\u0d08\u0d0a\7\u0099\2\2\u0d09\u0d08\3\2\2\2\u0d09\u0d0a"+
"\3\2\2\2\u0d0a\u01ff\3\2\2\2\u0d0b\u0d10\5\u0202\u0102\2\u0d0c\u0d0d\7"+
"\u0099\2\2\u0d0d\u0d0f\5\u0202\u0102\2\u0d0e\u0d0c\3\2\2\2\u0d0f\u0d12"+
"\3\2\2\2\u0d10\u0d0e\3\2\2\2\u0d10\u0d11\3\2\2\2\u0d11\u0d14\3\2\2\2\u0d12"+
"\u0d10\3\2\2\2\u0d13\u0d15\7\u0099\2\2\u0d14\u0d13\3\2\2\2\u0d14\u0d15"+
"\3\2\2\2\u0d15\u0201\3\2\2\2\u0d16\u0d19\5\u01f6\u00fc\2\u0d17\u0d19\5"+
"\u01d2\u00ea\2\u0d18\u0d16\3\2\2\2\u0d18\u0d17\3\2\2\2\u0d19\u0d1a\3\2"+
"\2\2\u0d1a\u0d1b\7\u0098\2\2\u0d1b\u0d1c\5\u01f8\u00fd\2\u0d1c\u0203\3"+
"\2\2\2\u01e2\u0206\u0208\u0216\u021a\u021d\u0220\u0225\u0228\u022c\u0235"+
"\u023e\u0245\u0254\u0257\u025e\u026a\u0272\u0275\u0278\u027d\u028d\u0290"+
"\u0297\u029b\u02a1\u02a4\u02a8\u02ad\u02b1\u02b5\u02ba\u02be\u02c7\u02ca"+
"\u02cc\u02d1\u02d5\u02da\u02e4\u02ea\u02ee\u02f4\u02f9\u02fe\u0300\u0304"+
"\u030a\u030f\u0318\u031d\u0320\u0327\u0331\u0336\u033e\u0344\u034a\u034e"+
"\u0352\u0355\u0358\u035c\u0360\u0365\u0369\u036e\u0372\u0379\u037f\u0386"+
"\u038a\u0391\u0396\u039c\u03a6\u03ae\u03b5\u03bb\u03bf\u03c2\u03c9\u03ce"+
"\u03d0\u03d6\u03dc\u03eb\u03f1\u03f4\u03f9\u03fc\u03fe\u0402\u0409\u040f"+
"\u041a\u0421\u0424\u0427\u042b\u042d\u0435\u043b\u0442\u0449\u044f\u0453"+
"\u045a\u045f\u0462\u0467\u0470\u0474\u0484\u048c\u0492\u0497\u049a\u049d"+
"\u04a1\u04a4\u04aa\u04b5\u04ba\u04bd\u04cf\u04d4\u04dc\u04e3\u04e7\u04ee"+
"\u04fc\u04fe\u0504\u0513\u0516\u051b\u0523\u0527\u052b\u052e\u0533\u0538"+
"\u053b\u053f\u0546\u054a\u054d\u0554\u055c\u0563\u0569\u056b\u0570\u0578"+
"\u057d\u0581\u0584\u058b\u0591\u0594\u059c\u05a4\u05ab\u05b0\u05bc\u05c1"+
"\u05c9\u05cf\u05d2\u05d9\u05df\u05e5\u05ec\u05f2\u05f5\u05f8\u05fd\u0605"+
"\u0611\u0614\u061d\u0623\u0627\u062a\u062d\u0637\u063d\u0640\u0645\u0648"+
"\u064c\u0652\u0655\u065b\u0668\u066d\u066f\u0678\u067b\u067e\u0686\u068f"+
"\u0692\u069a\u06a0\u06a4\u06a7\u06ae\u06b4\u06bd\u06ca\u06d1\u06da\u06dd"+
"\u06e0\u06e7\u06ed\u06f2\u06f8\u06fe\u0701\u0709\u070f\u0713\u0716\u0719"+
"\u0720\u0724\u072b\u072f\u0733\u0737\u0739\u0740\u0752\u0756\u0759\u075d"+
"\u0760\u076b\u0774\u077a\u077c\u0791\u0798\u079e\u07a3\u07ab\u07ae\u07b7"+
"\u07c0\u07c3\u07c5\u07c8\u07cc\u07cf\u07d2\u07dc\u07ea\u07ed\u07f8\u07fb"+
"\u0801\u0808\u0810\u0818\u081e\u0827\u082d\u0831\u0835\u0837\u083b\u0843"+
"\u0849\u084d\u0851\u0853\u0857\u085b\u0860\u0869\u086c\u0870\u087a\u087e"+
"\u0880\u088b\u088e\u0895\u089d\u08a7\u08b5\u08c2\u08c5\u08c9\u08d2\u08d7"+
"\u08da\u08e1\u08e9\u08ef\u08f3\u08fd\u0904\u0909\u090d\u0913\u0918\u091c"+
"\u0924\u0927\u092b\u0930\u0938\u0941\u0949\u0951\u0959\u0968\u0972\u0976"+
"\u097d\u0981\u098d\u09a9\u09ba\u09be\u09c8\u09cb\u09d0\u09d5\u09d9\u09dd"+
"\u09e1\u09e8\u09f0\u09f4\u09f7\u09fc\u09ff\u0a04\u0a0a\u0a16\u0a19\u0a20"+
"\u0a24\u0a32\u0a3a\u0a43\u0a4b\u0a4f\u0a54\u0a5a\u0a5d\u0a5f\u0a68\u0a6e"+
"\u0a76\u0a7f\u0a85\u0a89\u0a92\u0a9e\u0aa0\u0aa4\u0aaa\u0aaf\u0ab2\u0ab5"+
"\u0abb\u0ac0\u0ac4\u0ac8\u0acc\u0ad9\u0ae1\u0ae3\u0aea\u0af4\u0af9\u0afc"+
"\u0aff\u0b02\u0b0a\u0b10\u0b15\u0b1e\u0b26\u0b2e\u0b33\u0b37\u0b3e\u0b41"+
"\u0b48\u0b4b\u0b52\u0b5a\u0b67\u0b6b\u0b73\u0b7e\u0b83\u0b89\u0b8e\u0b95"+
"\u0b9f\u0ba7\u0bae\u0bb6\u0bbb\u0bbf\u0bc2\u0bc8\u0bcc\u0bd1\u0c07\u0c0c"+
"\u0c10\u0c14\u0c17\u0c1a\u0c1d\u0c20\u0c23\u0c26\u0c29\u0c2d\u0c30\u0c33"+
"\u0c36\u0c39\u0c3c\u0c3f\u0c43\u0c46\u0c49\u0c4c\u0c4f\u0c52\u0c56\u0c59"+
"\u0c5c\u0c5f\u0c62\u0c66\u0c69\u0c6c\u0c6f\u0c73\u0c76\u0c79\u0c7d\u0c80"+
"\u0c84\u0c87\u0c8c\u0c93\u0c9a\u0ca1\u0ca8\u0caf\u0cb6\u0cbd\u0cc4\u0ccd"+
"\u0cd1\u0cd3\u0cd6\u0cdd\u0ce5\u0ce9\u0cef\u0cf4\u0cfc\u0d05\u0d09\u0d10"+
"\u0d14\u0d18";
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);
}
}
}
