edu.uvm.ccts.arden.data.antlr.DataParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of arden-parser Show documentation
Show all versions of arden-parser Show documentation
ANTLR grammar and Java logic used to traverse the generated abstract syntax trees related to Arden-syntax Medical Logic Modules (MLMs)
// Generated from Data.g4 by ANTLR 4.1
package edu.uvm.ccts.arden.data.antlr;
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 DataParser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__7=1, T__6=2, T__5=3, T__4=4, T__3=5, T__2=6, T__1=7, T__0=8, Read=9,
It=10, They=11, Event=12, Mlm=13, Institution=14, Argument=15, Interface=16,
Message=17, Destination=18, Include=19, Mapping=20, Term=21, If=22, Then=23,
ElsIf=24, Else=25, EndIf=26, While=27, Do=28, EndDo=29, Switch=30, Case=31,
Default=32, EndSwitch=33, BreakLoop=34, Continue=35, And=36, Or=37, SeqTo=38,
AsNumber=39, AsTime=40, AsString=41, Plus=42, Minus=43, Mul=44, Div=45,
Pow=46, Arccos=47, Arcsin=48, Arctan=49, Cosine=50, Sine=51, Tangent=52,
Exp=53, Log=54, Log10=55, Int=56, Floor=57, Ceiling=58, Truncate=59, Round=60,
Abs=61, Sqrt=62, LessThan=63, LessThanOrEqual=64, EqualTo=65, NotEqualTo=66,
GreaterThan=67, GreaterThanOrEqual=68, Min=69, Max=70, Earliest=71, Latest=72,
Nearest=73, Least=74, Most=75, First=76, Last=77, Count=78, Interval=79,
Exist=80, Avg=81, Median=82, Sum=83, Stddev=84, Variance=85, Index=86,
Any=87, All=88, No=89, Of=90, IsTrue=91, AreTrue=92, Ago=93, AtTime=94,
Time=95, Is=96, String=97, MatchesPattern=98, Length=99, Uppercase=100,
Lowercase=101, Trim=102, Left=103, Right=104, Find=105, StartingAt=106,
Substring=107, Characters=108, Add=109, Elements=110, Percent=111, Increase=112,
Decrease=113, List=114, Sublist=115, Remove=116, Merge=117, WhereTimePresent=118,
Sort=119, Data=120, Year=121, Month=122, Week=123, Day=124, Hour=125,
Minute=126, Second=127, Years=128, Months=129, Weeks=130, Days=131, Hours=132,
Minutes=133, Seconds=134, New=135, Clone=136, Attribute=137, Names=138,
Extract=139, Duration=140, Null=141, Boolean=142, BooleanVal=143, Replace=144,
Present=145, TimeOfDay=146, Reverse=147, EmptyList=148, Concat=149, Number=150,
NumberVal=151, IntVal=152, Now=153, CurrentTime=154, TimeVal=155, TimeOfDayFunc=156,
TimeOfDayVal=157, DayOfWeekFunc=158, DayOfWeek=159, Print=160, For=161,
Let=162, Be=163, As=164, Where=165, Within=166, The=167, To=168, Preceding=169,
Following=170, Surrounding=171, Past=172, SameDayAs=173, Before=174, After=175,
Occur=176, Not=177, In=178, At=179, From=180, Call=181, With=182, Equal=183,
Object=184, StringVal=185, ID=186, S=187, LINE_COMMENT=188, COMMENT=189,
WS=190;
public static final String[] tokenNames = {
"", "']'", "')'", "'.'", "','", "':='", "'['", "'('", "';'",
"Read", "It", "They", "Event", "Mlm", "Institution", "Argument", "Interface",
"Message", "Destination", "Include", "Mapping", "Term", "If", "Then",
"ElsIf", "Else", "EndIf", "While", "Do", "EndDo", "Switch", "Case", "Default",
"EndSwitch", "BreakLoop", "Continue", "And", "Or", "SeqTo", "AsNumber",
"AsTime", "AsString", "'+'", "'-'", "'*'", "'/'", "'**'", "Arccos", "Arcsin",
"Arctan", "Cosine", "Sine", "Tangent", "Exp", "Log", "Log10", "Int", "Floor",
"Ceiling", "Truncate", "Round", "Abs", "Sqrt", "LessThan", "LessThanOrEqual",
"EqualTo", "NotEqualTo", "GreaterThan", "GreaterThanOrEqual", "Min", "Max",
"Earliest", "Latest", "Nearest", "Least", "Most", "First", "Last", "Count",
"Interval", "Exist", "Avg", "Median", "Sum", "Stddev", "Variance", "Index",
"Any", "All", "No", "Of", "IsTrue", "AreTrue", "Ago", "AtTime", "Time",
"Is", "String", "MatchesPattern", "Length", "Uppercase", "Lowercase",
"Trim", "Left", "Right", "Find", "StartingAt", "Substring", "Characters",
"Add", "Elements", "Percent", "Increase", "Decrease", "List", "Sublist",
"Remove", "Merge", "WhereTimePresent", "Sort", "Data", "Year", "Month",
"Week", "Day", "Hour", "Minute", "Second", "Years", "Months", "Weeks",
"Days", "Hours", "Minutes", "Seconds", "New", "Clone", "Attribute", "Names",
"Extract", "Duration", "Null", "Boolean", "BooleanVal", "Replace", "Present",
"TimeOfDay", "Reverse", "EmptyList", "'||'", "Number", "NumberVal", "IntVal",
"Now", "CurrentTime", "TimeVal", "TimeOfDayFunc", "TimeOfDayVal", "DayOfWeekFunc",
"DayOfWeek", "Print", "For", "Let", "Be", "As", "Where", "Within", "The",
"To", "Preceding", "Following", "Surrounding", "Past", "SameDayAs", "Before",
"After", "Occur", "Not", "In", "At", "From", "Call", "With", "Equal",
"Object", "StringVal", "ID", "S", "LINE_COMMENT", "COMMENT", "WS"
};
public static final int
RULE_block = 0, RULE_ifStatement = 1, RULE_switchStatement = 2, RULE_whileLoop = 3,
RULE_forLoop = 4, RULE_breakLoop = 5, RULE_continueLoop = 6, RULE_init = 7,
RULE_print = 8, RULE_stmt = 9, RULE_assignmentStatement = 10, RULE_objOrIndexRule = 11,
RULE_assignable = 12, RULE_declareObject = 13, RULE_call = 14, RULE_include = 15,
RULE_read = 16, RULE_readAs = 17, RULE_declareEvent = 18, RULE_declareMlm = 19,
RULE_declareInterface = 20, RULE_declareMessage = 21, RULE_declareMessageAs = 22,
RULE_declareDestination = 23, RULE_declareDestinationAs = 24, RULE_argument = 25,
RULE_aggregation = 26, RULE_transformation = 27, RULE_constraint = 28,
RULE_indexType = 29, RULE_dataType = 30, RULE_durationUnit = 31, RULE_durationExpr = 32,
RULE_temporalUnit = 33, RULE_expr = 34, RULE_objOrderedWith = 35, RULE_objNamedWith = 36;
public static final String[] ruleNames = {
"block", "ifStatement", "switchStatement", "whileLoop", "forLoop", "breakLoop",
"continueLoop", "init", "print", "stmt", "assignmentStatement", "objOrIndexRule",
"assignable", "declareObject", "call", "include", "read", "readAs", "declareEvent",
"declareMlm", "declareInterface", "declareMessage", "declareMessageAs",
"declareDestination", "declareDestinationAs", "argument", "aggregation",
"transformation", "constraint", "indexType", "dataType", "durationUnit",
"durationExpr", "temporalUnit", "expr", "objOrderedWith", "objNamedWith"
};
@Override
public String getGrammarFileName() { return "Data.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public ATN getATN() { return _ATN; }
private static final List stack = new ArrayList();
private static void push(Boolean b) { stack.add(0, b); }
private static void pop() { if (stack.size() > 0) stack.remove(0); }
private static Boolean list() { return stack.size() > 0 ? stack.get(0) : true; }
public DataParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class BlockContext extends ParserRuleContext {
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 0, RULE_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(77);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 7) | (1L << Include) | (1L << If) | (1L << While) | (1L << Switch) | (1L << BreakLoop) | (1L << Continue))) != 0) || ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & ((1L << (Print - 160)) | (1L << (For - 160)) | (1L << (Let - 160)) | (1L << (Call - 160)) | (1L << (ID - 160)))) != 0)) {
{
{
setState(74); stmt();
}
}
setState(79);
_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 IfStatementContext extends ParserRuleContext {
public TerminalNode Then(int i) {
return getToken(DataParser.Then, i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Else() { return getToken(DataParser.Else, 0); }
public TerminalNode EndIf() { return getToken(DataParser.EndIf, 0); }
public BlockContext block(int i) {
return getRuleContext(BlockContext.class,i);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode If() { return getToken(DataParser.If, 0); }
public TerminalNode ElsIf(int i) {
return getToken(DataParser.ElsIf, i);
}
public List block() {
return getRuleContexts(BlockContext.class);
}
public List ElsIf() { return getTokens(DataParser.ElsIf); }
public List Then() { return getTokens(DataParser.Then); }
public IfStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifStatement; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIfStatement(this);
else return visitor.visitChildren(this);
}
}
public final IfStatementContext ifStatement() throws RecognitionException {
IfStatementContext _localctx = new IfStatementContext(_ctx, getState());
enterRule(_localctx, 2, RULE_ifStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(80); match(If);
setState(81); expr(0);
setState(82); match(Then);
setState(83); block();
setState(91);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ElsIf) {
{
{
setState(84); match(ElsIf);
setState(85); expr(0);
setState(86); match(Then);
setState(87); block();
}
}
setState(93);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(96);
_la = _input.LA(1);
if (_la==Else) {
{
setState(94); match(Else);
setState(95); block();
}
}
setState(98); match(EndIf);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchStatementContext extends ParserRuleContext {
public TerminalNode EndSwitch() { return getToken(DataParser.EndSwitch, 0); }
public TerminalNode Default() { return getToken(DataParser.Default, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public List Case() { return getTokens(DataParser.Case); }
public BlockContext block(int i) {
return getRuleContext(BlockContext.class,i);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public TerminalNode Switch() { return getToken(DataParser.Switch, 0); }
public List block() {
return getRuleContexts(BlockContext.class);
}
public TerminalNode Case(int i) {
return getToken(DataParser.Case, i);
}
public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchStatement; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSwitchStatement(this);
else return visitor.visitChildren(this);
}
}
public final SwitchStatementContext switchStatement() throws RecognitionException {
SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
enterRule(_localctx, 4, RULE_switchStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(100); match(Switch);
setState(101); match(ID);
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(102); match(Case);
setState(103); expr(0);
setState(104); block();
}
}
setState(108);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Case );
setState(112);
_la = _input.LA(1);
if (_la==Default) {
{
setState(110); match(Default);
setState(111); block();
}
}
setState(114); match(EndSwitch);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhileLoopContext extends ParserRuleContext {
public TerminalNode While() { return getToken(DataParser.While, 0); }
public TerminalNode Do() { return getToken(DataParser.Do, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode EndDo() { return getToken(DataParser.EndDo, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public WhileLoopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whileLoop; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitWhileLoop(this);
else return visitor.visitChildren(this);
}
}
public final WhileLoopContext whileLoop() throws RecognitionException {
WhileLoopContext _localctx = new WhileLoopContext(_ctx, getState());
enterRule(_localctx, 6, RULE_whileLoop);
try {
enterOuterAlt(_localctx, 1);
{
setState(116); match(While);
setState(117); expr(0);
setState(118); match(Do);
setState(119); block();
setState(120); match(EndDo);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForLoopContext extends ParserRuleContext {
public TerminalNode For() { return getToken(DataParser.For, 0); }
public TerminalNode Do() { return getToken(DataParser.Do, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public TerminalNode EndDo() { return getToken(DataParser.EndDo, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode In() { return getToken(DataParser.In, 0); }
public ForLoopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forLoop; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitForLoop(this);
else return visitor.visitChildren(this);
}
}
public final ForLoopContext forLoop() throws RecognitionException {
ForLoopContext _localctx = new ForLoopContext(_ctx, getState());
enterRule(_localctx, 8, RULE_forLoop);
try {
enterOuterAlt(_localctx, 1);
{
setState(122); match(For);
setState(123); match(ID);
setState(124); match(In);
setState(125); expr(0);
setState(126); match(Do);
setState(127); block();
setState(128); match(EndDo);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BreakLoopContext extends ParserRuleContext {
public TerminalNode BreakLoop() { return getToken(DataParser.BreakLoop, 0); }
public BreakLoopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_breakLoop; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitBreakLoop(this);
else return visitor.visitChildren(this);
}
}
public final BreakLoopContext breakLoop() throws RecognitionException {
BreakLoopContext _localctx = new BreakLoopContext(_ctx, getState());
enterRule(_localctx, 10, RULE_breakLoop);
try {
enterOuterAlt(_localctx, 1);
{
setState(130); match(BreakLoop);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContinueLoopContext extends ParserRuleContext {
public TerminalNode Continue() { return getToken(DataParser.Continue, 0); }
public ContinueLoopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continueLoop; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitContinueLoop(this);
else return visitor.visitChildren(this);
}
}
public final ContinueLoopContext continueLoop() throws RecognitionException {
ContinueLoopContext _localctx = new ContinueLoopContext(_ctx, getState());
enterRule(_localctx, 12, RULE_continueLoop);
try {
enterOuterAlt(_localctx, 1);
{
setState(132); match(Continue);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InitContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(DataParser.EOF, 0); }
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public InitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_init; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitInit(this);
else return visitor.visitChildren(this);
}
}
public final InitContext init() throws RecognitionException {
InitContext _localctx = new InitContext(_ctx, getState());
enterRule(_localctx, 14, RULE_init);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(137);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 7) | (1L << Include) | (1L << If) | (1L << While) | (1L << Switch) | (1L << BreakLoop) | (1L << Continue))) != 0) || ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & ((1L << (Print - 160)) | (1L << (For - 160)) | (1L << (Let - 160)) | (1L << (Call - 160)) | (1L << (ID - 160)))) != 0)) {
{
{
setState(134); stmt();
}
}
setState(139);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(140); match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrintContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Print() { return getToken(DataParser.Print, 0); }
public PrintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_print; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitPrint(this);
else return visitor.visitChildren(this);
}
}
public final PrintContext print() throws RecognitionException {
PrintContext _localctx = new PrintContext(_ctx, getState());
enterRule(_localctx, 16, RULE_print);
try {
enterOuterAlt(_localctx, 1);
{
setState(142); match(Print);
setState(143); expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StmtContext extends ParserRuleContext {
public ContinueLoopContext continueLoop() {
return getRuleContext(ContinueLoopContext.class,0);
}
public AssignmentStatementContext assignmentStatement() {
return getRuleContext(AssignmentStatementContext.class,0);
}
public PrintContext print() {
return getRuleContext(PrintContext.class,0);
}
public WhileLoopContext whileLoop() {
return getRuleContext(WhileLoopContext.class,0);
}
public IfStatementContext ifStatement() {
return getRuleContext(IfStatementContext.class,0);
}
public IncludeContext include() {
return getRuleContext(IncludeContext.class,0);
}
public ForLoopContext forLoop() {
return getRuleContext(ForLoopContext.class,0);
}
public BreakLoopContext breakLoop() {
return getRuleContext(BreakLoopContext.class,0);
}
public CallContext call() {
return getRuleContext(CallContext.class,0);
}
public SwitchStatementContext switchStatement() {
return getRuleContext(SwitchStatementContext.class,0);
}
public StmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitStmt(this);
else return visitor.visitChildren(this);
}
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 18, RULE_stmt);
try {
setState(175);
switch (_input.LA(1)) {
case 7:
case Let:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(145); assignmentStatement();
setState(146); match(8);
}
break;
case If:
enterOuterAlt(_localctx, 2);
{
setState(148); ifStatement();
setState(149); match(8);
}
break;
case Switch:
enterOuterAlt(_localctx, 3);
{
setState(151); switchStatement();
setState(152); match(8);
}
break;
case Include:
enterOuterAlt(_localctx, 4);
{
setState(154); include();
setState(155); match(8);
}
break;
case While:
enterOuterAlt(_localctx, 5);
{
setState(157); whileLoop();
setState(158); match(8);
}
break;
case For:
enterOuterAlt(_localctx, 6);
{
setState(160); forLoop();
setState(161); match(8);
}
break;
case BreakLoop:
enterOuterAlt(_localctx, 7);
{
setState(163); breakLoop();
setState(164); match(8);
}
break;
case Continue:
enterOuterAlt(_localctx, 8);
{
setState(166); continueLoop();
setState(167); match(8);
}
break;
case Call:
enterOuterAlt(_localctx, 9);
{
setState(169); call();
setState(170); match(8);
}
break;
case Print:
enterOuterAlt(_localctx, 10);
{
setState(172); print();
setState(173); match(8);
}
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 AssignmentStatementContext extends ParserRuleContext {
public AssignmentStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentStatement; }
public AssignmentStatementContext() { }
public void copyFrom(AssignmentStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class AssignmentContext extends AssignmentStatementContext {
public AssignableContext assignable() {
return getRuleContext(AssignableContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public TerminalNode Let() { return getToken(DataParser.Let, 0); }
public TerminalNode Be() { return getToken(DataParser.Be, 0); }
public AssignmentContext(AssignmentStatementContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAssignment(this);
else return visitor.visitChildren(this);
}
}
public static class MultipleAssignmentContext extends AssignmentStatementContext {
public AssignableContext assignable() {
return getRuleContext(AssignableContext.class,0);
}
public List ID() { return getTokens(DataParser.ID); }
public TerminalNode Let() { return getToken(DataParser.Let, 0); }
public TerminalNode Be() { return getToken(DataParser.Be, 0); }
public TerminalNode ID(int i) {
return getToken(DataParser.ID, i);
}
public MultipleAssignmentContext(AssignmentStatementContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMultipleAssignment(this);
else return visitor.visitChildren(this);
}
}
public static class EnhancedAssignmentContext extends AssignmentStatementContext {
public AssignableContext assignable() {
return getRuleContext(AssignableContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public List objOrIndexRule() {
return getRuleContexts(ObjOrIndexRuleContext.class);
}
public ObjOrIndexRuleContext objOrIndexRule(int i) {
return getRuleContext(ObjOrIndexRuleContext.class,i);
}
public EnhancedAssignmentContext(AssignmentStatementContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitEnhancedAssignment(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentStatementContext assignmentStatement() throws RecognitionException {
AssignmentStatementContext _localctx = new AssignmentStatementContext(_ctx, getState());
enterRule(_localctx, 20, RULE_assignmentStatement);
int _la;
try {
setState(218);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
_localctx = new AssignmentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(177); match(ID);
setState(178); match(5);
setState(179); assignable();
}
break;
case 2:
_localctx = new AssignmentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(180); match(Let);
setState(181); match(ID);
setState(182); match(Be);
setState(183); assignable();
}
break;
case 3:
_localctx = new MultipleAssignmentContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(184); match(7);
setState(185); match(ID);
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==4) {
{
{
setState(186); match(4);
setState(187); match(ID);
}
}
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(193); match(2);
setState(194); match(5);
setState(195); assignable();
}
break;
case 4:
_localctx = new MultipleAssignmentContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(196); match(Let);
setState(197); match(7);
setState(198); match(ID);
setState(203);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==4) {
{
{
setState(199); match(4);
setState(200); match(ID);
}
}
setState(205);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(206); match(2);
setState(207); match(Be);
setState(208); assignable();
}
break;
case 5:
_localctx = new EnhancedAssignmentContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(209); match(ID);
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(210); objOrIndexRule();
}
}
setState(213);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==3 || _la==6 );
setState(215); match(5);
setState(216); assignable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjOrIndexRuleContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public ObjOrIndexRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objOrIndexRule; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitObjOrIndexRule(this);
else return visitor.visitChildren(this);
}
}
public final ObjOrIndexRuleContext objOrIndexRule() throws RecognitionException {
ObjOrIndexRuleContext _localctx = new ObjOrIndexRuleContext(_ctx, getState());
enterRule(_localctx, 22, RULE_objOrIndexRule);
try {
setState(226);
switch (_input.LA(1)) {
case 3:
enterOuterAlt(_localctx, 1);
{
setState(220); match(3);
setState(221); match(ID);
}
break;
case 6:
enterOuterAlt(_localctx, 2);
{
setState(222); match(6);
setState(223); expr(0);
setState(224); match(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 AssignableContext extends ParserRuleContext {
public DeclareDestinationContext declareDestination() {
return getRuleContext(DeclareDestinationContext.class,0);
}
public ReadContext read() {
return getRuleContext(ReadContext.class,0);
}
public CallContext call() {
return getRuleContext(CallContext.class,0);
}
public DeclareMessageAsContext declareMessageAs() {
return getRuleContext(DeclareMessageAsContext.class,0);
}
public DeclareMlmContext declareMlm() {
return getRuleContext(DeclareMlmContext.class,0);
}
public DeclareInterfaceContext declareInterface() {
return getRuleContext(DeclareInterfaceContext.class,0);
}
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public DeclareEventContext declareEvent() {
return getRuleContext(DeclareEventContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public DeclareDestinationAsContext declareDestinationAs() {
return getRuleContext(DeclareDestinationAsContext.class,0);
}
public DeclareObjectContext declareObject() {
return getRuleContext(DeclareObjectContext.class,0);
}
public DeclareMessageContext declareMessage() {
return getRuleContext(DeclareMessageContext.class,0);
}
public ReadAsContext readAs() {
return getRuleContext(ReadAsContext.class,0);
}
public AssignableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignable; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAssignable(this);
else return visitor.visitChildren(this);
}
}
public final AssignableContext assignable() throws RecognitionException {
AssignableContext _localctx = new AssignableContext(_ctx, getState());
enterRule(_localctx, 24, RULE_assignable);
try {
setState(241);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(228); expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(229); read();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(230); readAs();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(231); declareObject();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(232); declareEvent();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(233); declareMlm();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(234); declareInterface();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(235); declareMessage();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(236); declareMessageAs();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(237); declareDestination();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(238); declareDestinationAs();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(239); argument();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(240); call();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareObjectContext extends ParserRuleContext {
public List ID() { return getTokens(DataParser.ID); }
public TerminalNode Object() { return getToken(DataParser.Object, 0); }
public TerminalNode ID(int i) {
return getToken(DataParser.ID, i);
}
public DeclareObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareObject; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareObject(this);
else return visitor.visitChildren(this);
}
}
public final DeclareObjectContext declareObject() throws RecognitionException {
DeclareObjectContext _localctx = new DeclareObjectContext(_ctx, getState());
enterRule(_localctx, 26, RULE_declareObject);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(243); match(Object);
setState(244); match(6);
setState(245); match(ID);
setState(250);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==4) {
{
{
setState(246); match(4);
setState(247); match(ID);
}
}
setState(252);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(253); match(1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CallContext extends ParserRuleContext {
public TerminalNode With() { return getToken(DataParser.With, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Call() { return getToken(DataParser.Call, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public CallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_call; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitCall(this);
else return visitor.visitChildren(this);
}
}
public final CallContext call() throws RecognitionException {
CallContext _localctx = new CallContext(_ctx, getState());
enterRule(_localctx, 28, RULE_call);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(255); match(Call);
setState(256); match(ID);
setState(266);
_la = _input.LA(1);
if (_la==With) {
{
setState(257); match(With);
setState(258); expr(0);
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==4) {
{
{
setState(259); match(4);
setState(260); expr(0);
}
}
setState(265);
_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 IncludeContext extends ParserRuleContext {
public TerminalNode Include() { return getToken(DataParser.Include, 0); }
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public IncludeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_include; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitInclude(this);
else return visitor.visitChildren(this);
}
}
public final IncludeContext include() throws RecognitionException {
IncludeContext _localctx = new IncludeContext(_ctx, getState());
enterRule(_localctx, 30, RULE_include);
try {
enterOuterAlt(_localctx, 1);
{
setState(268); match(Include);
setState(269); match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadContext extends ParserRuleContext {
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public TransformationContext transformation() {
return getRuleContext(TransformationContext.class,0);
}
public AggregationContext aggregation() {
return getRuleContext(AggregationContext.class,0);
}
public TerminalNode Read() { return getToken(DataParser.Read, 0); }
public TerminalNode Where() { return getToken(DataParser.Where, 0); }
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public ReadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_read; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitRead(this);
else return visitor.visitChildren(this);
}
}
public final ReadContext read() throws RecognitionException {
ReadContext _localctx = new ReadContext(_ctx, getState());
enterRule(_localctx, 32, RULE_read);
int _la;
try {
setState(293);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(271); match(Read);
setState(274);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
setState(272); aggregation();
}
break;
case 2:
{
setState(273); transformation();
}
break;
}
setState(276); match(Mapping);
setState(279);
_la = _input.LA(1);
if (_la==Where) {
{
setState(277); match(Where);
setState(278); constraint();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(281); match(Read);
setState(284);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(282); aggregation();
}
break;
case 2:
{
setState(283); transformation();
}
break;
}
setState(286); match(7);
setState(287); match(Mapping);
setState(290);
_la = _input.LA(1);
if (_la==Where) {
{
setState(288); match(Where);
setState(289); constraint();
}
}
setState(292); match(2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadAsContext extends ParserRuleContext {
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public TransformationContext transformation() {
return getRuleContext(TransformationContext.class,0);
}
public AggregationContext aggregation() {
return getRuleContext(AggregationContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public TerminalNode Read() { return getToken(DataParser.Read, 0); }
public TerminalNode Where() { return getToken(DataParser.Where, 0); }
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public TerminalNode As() { return getToken(DataParser.As, 0); }
public ReadAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readAs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitReadAs(this);
else return visitor.visitChildren(this);
}
}
public final ReadAsContext readAs() throws RecognitionException {
ReadAsContext _localctx = new ReadAsContext(_ctx, getState());
enterRule(_localctx, 34, RULE_readAs);
int _la;
try {
setState(321);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(295); match(Read);
setState(296); match(As);
setState(297); match(ID);
setState(300);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(298); aggregation();
}
break;
case 2:
{
setState(299); transformation();
}
break;
}
setState(302); match(Mapping);
setState(305);
_la = _input.LA(1);
if (_la==Where) {
{
setState(303); match(Where);
setState(304); constraint();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(307); match(Read);
setState(308); match(As);
setState(309); match(ID);
setState(312);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(310); aggregation();
}
break;
case 2:
{
setState(311); transformation();
}
break;
}
setState(314); match(7);
setState(315); match(Mapping);
setState(318);
_la = _input.LA(1);
if (_la==Where) {
{
setState(316); match(Where);
setState(317); constraint();
}
}
setState(320); match(2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareEventContext extends ParserRuleContext {
public TerminalNode Event() { return getToken(DataParser.Event, 0); }
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public DeclareEventContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareEvent; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareEvent(this);
else return visitor.visitChildren(this);
}
}
public final DeclareEventContext declareEvent() throws RecognitionException {
DeclareEventContext _localctx = new DeclareEventContext(_ctx, getState());
enterRule(_localctx, 36, RULE_declareEvent);
try {
enterOuterAlt(_localctx, 1);
{
setState(323); match(Event);
setState(324); match(Mapping);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareMlmContext extends ParserRuleContext {
public TerminalNode StringVal() { return getToken(DataParser.StringVal, 0); }
public TerminalNode From() { return getToken(DataParser.From, 0); }
public TerminalNode Term() { return getToken(DataParser.Term, 0); }
public TerminalNode Mlm() { return getToken(DataParser.Mlm, 0); }
public TerminalNode Institution() { return getToken(DataParser.Institution, 0); }
public DeclareMlmContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareMlm; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareMlm(this);
else return visitor.visitChildren(this);
}
}
public final DeclareMlmContext declareMlm() throws RecognitionException {
DeclareMlmContext _localctx = new DeclareMlmContext(_ctx, getState());
enterRule(_localctx, 38, RULE_declareMlm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326); match(Mlm);
setState(327); match(Term);
setState(331);
_la = _input.LA(1);
if (_la==From) {
{
setState(328); match(From);
setState(329); match(Institution);
setState(330); match(StringVal);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareInterfaceContext extends ParserRuleContext {
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public TerminalNode Interface() { return getToken(DataParser.Interface, 0); }
public DeclareInterfaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareInterface; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareInterface(this);
else return visitor.visitChildren(this);
}
}
public final DeclareInterfaceContext declareInterface() throws RecognitionException {
DeclareInterfaceContext _localctx = new DeclareInterfaceContext(_ctx, getState());
enterRule(_localctx, 40, RULE_declareInterface);
try {
enterOuterAlt(_localctx, 1);
{
setState(333); match(Interface);
setState(334); match(Mapping);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareMessageContext extends ParserRuleContext {
public TerminalNode Message() { return getToken(DataParser.Message, 0); }
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public DeclareMessageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareMessage; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareMessage(this);
else return visitor.visitChildren(this);
}
}
public final DeclareMessageContext declareMessage() throws RecognitionException {
DeclareMessageContext _localctx = new DeclareMessageContext(_ctx, getState());
enterRule(_localctx, 42, RULE_declareMessage);
try {
enterOuterAlt(_localctx, 1);
{
setState(336); match(Message);
setState(337); match(Mapping);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareMessageAsContext extends ParserRuleContext {
public TerminalNode Message() { return getToken(DataParser.Message, 0); }
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public TerminalNode As() { return getToken(DataParser.As, 0); }
public DeclareMessageAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareMessageAs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareMessageAs(this);
else return visitor.visitChildren(this);
}
}
public final DeclareMessageAsContext declareMessageAs() throws RecognitionException {
DeclareMessageAsContext _localctx = new DeclareMessageAsContext(_ctx, getState());
enterRule(_localctx, 44, RULE_declareMessageAs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(339); match(Message);
setState(340); match(As);
setState(341); match(ID);
setState(343);
_la = _input.LA(1);
if (_la==Mapping) {
{
setState(342); match(Mapping);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareDestinationContext extends ParserRuleContext {
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public TerminalNode Destination() { return getToken(DataParser.Destination, 0); }
public DeclareDestinationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareDestination; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareDestination(this);
else return visitor.visitChildren(this);
}
}
public final DeclareDestinationContext declareDestination() throws RecognitionException {
DeclareDestinationContext _localctx = new DeclareDestinationContext(_ctx, getState());
enterRule(_localctx, 46, RULE_declareDestination);
try {
enterOuterAlt(_localctx, 1);
{
setState(345); match(Destination);
setState(346); match(Mapping);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclareDestinationAsContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public TerminalNode Mapping() { return getToken(DataParser.Mapping, 0); }
public TerminalNode As() { return getToken(DataParser.As, 0); }
public TerminalNode Destination() { return getToken(DataParser.Destination, 0); }
public DeclareDestinationAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declareDestinationAs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDeclareDestinationAs(this);
else return visitor.visitChildren(this);
}
}
public final DeclareDestinationAsContext declareDestinationAs() throws RecognitionException {
DeclareDestinationAsContext _localctx = new DeclareDestinationAsContext(_ctx, getState());
enterRule(_localctx, 48, RULE_declareDestinationAs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(348); match(Destination);
setState(349); match(As);
setState(350); match(ID);
setState(352);
_la = _input.LA(1);
if (_la==Mapping) {
{
setState(351); match(Mapping);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentContext extends ParserRuleContext {
public TerminalNode Argument() { return getToken(DataParser.Argument, 0); }
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitArgument(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 50, RULE_argument);
try {
enterOuterAlt(_localctx, 1);
{
setState(354); match(Argument);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AggregationContext extends ParserRuleContext {
public TerminalNode First() { return getToken(DataParser.First, 0); }
public TerminalNode Latest() { return getToken(DataParser.Latest, 0); }
public TerminalNode Last() { return getToken(DataParser.Last, 0); }
public TerminalNode Exist() { return getToken(DataParser.Exist, 0); }
public TerminalNode Earliest() { return getToken(DataParser.Earliest, 0); }
public TerminalNode Avg() { return getToken(DataParser.Avg, 0); }
public TerminalNode Sum() { return getToken(DataParser.Sum, 0); }
public TerminalNode Max() { return getToken(DataParser.Max, 0); }
public TerminalNode Min() { return getToken(DataParser.Min, 0); }
public AggregationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggregation; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAggregation(this);
else return visitor.visitChildren(this);
}
}
public final AggregationContext aggregation() throws RecognitionException {
AggregationContext _localctx = new AggregationContext(_ctx, getState());
enterRule(_localctx, 52, RULE_aggregation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(356);
_la = _input.LA(1);
if ( !(((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (Min - 69)) | (1L << (Max - 69)) | (1L << (Earliest - 69)) | (1L << (Latest - 69)) | (1L << (First - 69)) | (1L << (Last - 69)) | (1L << (Exist - 69)) | (1L << (Avg - 69)) | (1L << (Sum - 69)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransformationContext extends ParserRuleContext {
public TerminalNode First() { return getToken(DataParser.First, 0); }
public TerminalNode From() { return getToken(DataParser.From, 0); }
public TerminalNode Latest() { return getToken(DataParser.Latest, 0); }
public TerminalNode Last() { return getToken(DataParser.Last, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Earliest() { return getToken(DataParser.Earliest, 0); }
public TerminalNode Max() { return getToken(DataParser.Max, 0); }
public TerminalNode Min() { return getToken(DataParser.Min, 0); }
public TransformationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transformation; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTransformation(this);
else return visitor.visitChildren(this);
}
}
public final TransformationContext transformation() throws RecognitionException {
TransformationContext _localctx = new TransformationContext(_ctx, getState());
enterRule(_localctx, 54, RULE_transformation);
try {
setState(382);
switch (_input.LA(1)) {
case Min:
enterOuterAlt(_localctx, 1);
{
setState(358); match(Min);
setState(359); expr(0);
setState(360); match(From);
}
break;
case Max:
enterOuterAlt(_localctx, 2);
{
setState(362); match(Max);
setState(363); expr(0);
setState(364); match(From);
}
break;
case First:
enterOuterAlt(_localctx, 3);
{
setState(366); match(First);
setState(367); expr(0);
setState(368); match(From);
}
break;
case Last:
enterOuterAlt(_localctx, 4);
{
setState(370); match(Last);
setState(371); expr(0);
setState(372); match(From);
}
break;
case Earliest:
enterOuterAlt(_localctx, 5);
{
setState(374); match(Earliest);
setState(375); expr(0);
setState(376); match(From);
}
break;
case Latest:
enterOuterAlt(_localctx, 6);
{
setState(378); match(Latest);
setState(379); expr(0);
setState(380); match(From);
}
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 ConstraintContext extends ParserRuleContext {
public TerminalNode The() { return getToken(DataParser.The, 0); }
public TerminalNode SameDayAs() { return getToken(DataParser.SameDayAs, 0); }
public TerminalNode After() { return getToken(DataParser.After, 0); }
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public TerminalNode Before() { return getToken(DataParser.Before, 0); }
public TerminalNode Following() { return getToken(DataParser.Following, 0); }
public TerminalNode It() { return getToken(DataParser.It, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public TerminalNode Surrounding() { return getToken(DataParser.Surrounding, 0); }
public TerminalNode They() { return getToken(DataParser.They, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Preceding() { return getToken(DataParser.Preceding, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode To() { return getToken(DataParser.To, 0); }
public TerminalNode Past() { return getToken(DataParser.Past, 0); }
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode At() { return getToken(DataParser.At, 0); }
public TerminalNode Equal() { return getToken(DataParser.Equal, 0); }
public ConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraint; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintContext constraint() throws RecognitionException {
ConstraintContext _localctx = new ConstraintContext(_ctx, getState());
enterRule(_localctx, 56, RULE_constraint);
int _la;
try {
setState(415);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(384);
_la = _input.LA(1);
if ( !(_la==It || _la==They) ) {
_errHandler.recoverInline(this);
}
consume();
setState(385); match(Occur);
setState(387);
_la = _input.LA(1);
if (_la==Not) {
{
setState(386); match(Not);
}
}
setState(389);
_la = _input.LA(1);
if ( !(((((_la - 174)) & ~0x3f) == 0 && ((1L << (_la - 174)) & ((1L << (Before - 174)) | (1L << (After - 174)) | (1L << (At - 174)) | (1L << (Equal - 174)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(390); expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(391);
_la = _input.LA(1);
if ( !(_la==It || _la==They) ) {
_errHandler.recoverInline(this);
}
consume();
setState(392); match(Occur);
setState(394);
_la = _input.LA(1);
if (_la==Not) {
{
setState(393); match(Not);
}
}
setState(396); match(Within);
setState(397); expr(0);
setState(398);
_la = _input.LA(1);
if ( !(((((_la - 168)) & ~0x3f) == 0 && ((1L << (_la - 168)) & ((1L << (To - 168)) | (1L << (Preceding - 168)) | (1L << (Following - 168)) | (1L << (Surrounding - 168)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(399); expr(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(401);
_la = _input.LA(1);
if ( !(_la==It || _la==They) ) {
_errHandler.recoverInline(this);
}
consume();
setState(402); match(Occur);
setState(404);
_la = _input.LA(1);
if (_la==Not) {
{
setState(403); match(Not);
}
}
setState(406); match(Within);
setState(412);
switch (_input.LA(1)) {
case The:
case Past:
{
setState(408);
_la = _input.LA(1);
if (_la==The) {
{
setState(407); match(The);
}
}
setState(410); match(Past);
}
break;
case SameDayAs:
{
setState(411); match(SameDayAs);
}
break;
default:
throw new NoViableAltException(this);
}
setState(414); expr(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IndexTypeContext extends ParserRuleContext {
public TerminalNode Latest() { return getToken(DataParser.Latest, 0); }
public TerminalNode Earliest() { return getToken(DataParser.Earliest, 0); }
public TerminalNode Max() { return getToken(DataParser.Max, 0); }
public TerminalNode Min() { return getToken(DataParser.Min, 0); }
public IndexTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIndexType(this);
else return visitor.visitChildren(this);
}
}
public final IndexTypeContext indexType() throws RecognitionException {
IndexTypeContext _localctx = new IndexTypeContext(_ctx, getState());
enterRule(_localctx, 58, RULE_indexType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(417);
_la = _input.LA(1);
if ( !(((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (Min - 69)) | (1L << (Max - 69)) | (1L << (Earliest - 69)) | (1L << (Latest - 69)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataTypeContext extends ParserRuleContext {
public TerminalNode String() { return getToken(DataParser.String, 0); }
public TerminalNode Time() { return getToken(DataParser.Time, 0); }
public TerminalNode Present() { return getToken(DataParser.Present, 0); }
public TerminalNode Number() { return getToken(DataParser.Number, 0); }
public TerminalNode Object() { return getToken(DataParser.Object, 0); }
public TerminalNode List() { return getToken(DataParser.List, 0); }
public TerminalNode Duration() { return getToken(DataParser.Duration, 0); }
public TerminalNode Null() { return getToken(DataParser.Null, 0); }
public TerminalNode TimeOfDay() { return getToken(DataParser.TimeOfDay, 0); }
public TerminalNode Boolean() { return getToken(DataParser.Boolean, 0); }
public DataTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDataType(this);
else return visitor.visitChildren(this);
}
}
public final DataTypeContext dataType() throws RecognitionException {
DataTypeContext _localctx = new DataTypeContext(_ctx, getState());
enterRule(_localctx, 60, RULE_dataType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
_la = _input.LA(1);
if ( !(((((_la - 95)) & ~0x3f) == 0 && ((1L << (_la - 95)) & ((1L << (Time - 95)) | (1L << (String - 95)) | (1L << (List - 95)) | (1L << (Duration - 95)) | (1L << (Null - 95)) | (1L << (Boolean - 95)) | (1L << (Present - 95)) | (1L << (TimeOfDay - 95)) | (1L << (Number - 95)))) != 0) || _la==Object) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DurationUnitContext extends ParserRuleContext {
public TerminalNode Minute() { return getToken(DataParser.Minute, 0); }
public TerminalNode Days() { return getToken(DataParser.Days, 0); }
public TerminalNode Second() { return getToken(DataParser.Second, 0); }
public TerminalNode Seconds() { return getToken(DataParser.Seconds, 0); }
public TerminalNode Weeks() { return getToken(DataParser.Weeks, 0); }
public TerminalNode Week() { return getToken(DataParser.Week, 0); }
public TerminalNode Minutes() { return getToken(DataParser.Minutes, 0); }
public TerminalNode Month() { return getToken(DataParser.Month, 0); }
public TerminalNode Hours() { return getToken(DataParser.Hours, 0); }
public TerminalNode Year() { return getToken(DataParser.Year, 0); }
public TerminalNode Years() { return getToken(DataParser.Years, 0); }
public TerminalNode Day() { return getToken(DataParser.Day, 0); }
public TerminalNode Months() { return getToken(DataParser.Months, 0); }
public TerminalNode Hour() { return getToken(DataParser.Hour, 0); }
public DurationUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_durationUnit; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDurationUnit(this);
else return visitor.visitChildren(this);
}
}
public final DurationUnitContext durationUnit() throws RecognitionException {
DurationUnitContext _localctx = new DurationUnitContext(_ctx, getState());
enterRule(_localctx, 62, RULE_durationUnit);
int _la;
try {
setState(428);
switch (_input.LA(1)) {
case Year:
case Years:
enterOuterAlt(_localctx, 1);
{
setState(421);
_la = _input.LA(1);
if ( !(_la==Year || _la==Years) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case Month:
case Months:
enterOuterAlt(_localctx, 2);
{
setState(422);
_la = _input.LA(1);
if ( !(_la==Month || _la==Months) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case Week:
case Weeks:
enterOuterAlt(_localctx, 3);
{
setState(423);
_la = _input.LA(1);
if ( !(_la==Week || _la==Weeks) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case Day:
case Days:
enterOuterAlt(_localctx, 4);
{
setState(424);
_la = _input.LA(1);
if ( !(_la==Day || _la==Days) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case Hour:
case Hours:
enterOuterAlt(_localctx, 5);
{
setState(425);
_la = _input.LA(1);
if ( !(_la==Hour || _la==Hours) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case Minute:
case Minutes:
enterOuterAlt(_localctx, 6);
{
setState(426);
_la = _input.LA(1);
if ( !(_la==Minute || _la==Minutes) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
case Second:
case Seconds:
enterOuterAlt(_localctx, 7);
{
setState(427);
_la = _input.LA(1);
if ( !(_la==Second || _la==Seconds) ) {
_errHandler.recoverInline(this);
}
consume();
}
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 DurationExprContext extends ParserRuleContext {
public List durationUnit() {
return getRuleContexts(DurationUnitContext.class);
}
public DurationUnitContext durationUnit(int i) {
return getRuleContext(DurationUnitContext.class,i);
}
public List NumberVal() { return getTokens(DataParser.NumberVal); }
public TerminalNode NumberVal(int i) {
return getToken(DataParser.NumberVal, i);
}
public DurationExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_durationExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDurationExpr(this);
else return visitor.visitChildren(this);
}
}
public final DurationExprContext durationExpr() throws RecognitionException {
DurationExprContext _localctx = new DurationExprContext(_ctx, getState());
enterRule(_localctx, 64, RULE_durationExpr);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(432);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(430); match(NumberVal);
setState(431); durationUnit();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(434);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
} while ( _alt!=2 && _alt!=-1 );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemporalUnitContext extends ParserRuleContext {
public TerminalNode Second() { return getToken(DataParser.Second, 0); }
public TerminalNode Month() { return getToken(DataParser.Month, 0); }
public TerminalNode Minute() { return getToken(DataParser.Minute, 0); }
public TerminalNode Year() { return getToken(DataParser.Year, 0); }
public TerminalNode Day() { return getToken(DataParser.Day, 0); }
public TerminalNode Hour() { return getToken(DataParser.Hour, 0); }
public TemporalUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_temporalUnit; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTemporalUnit(this);
else return visitor.visitChildren(this);
}
}
public final TemporalUnitContext temporalUnit() throws RecognitionException {
TemporalUnitContext _localctx = new TemporalUnitContext(_ctx, getState());
enterRule(_localctx, 66, RULE_temporalUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(436);
_la = _input.LA(1);
if ( !(((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & ((1L << (Year - 121)) | (1L << (Month - 121)) | (1L << (Day - 121)) | (1L << (Hour - 121)) | (1L << (Minute - 121)) | (1L << (Second - 121)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public int _p;
public ExprContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
public ExprContext(ParserRuleContext parent, int invokingState, int _p) {
super(parent, invokingState);
this._p = _p;
}
@Override public int getRuleIndex() { return RULE_expr; }
public ExprContext() { }
public void copyFrom(ExprContext ctx) {
super.copyFrom(ctx);
this._p = ctx._p;
}
}
public static class ArccosContext extends ExprContext {
public TerminalNode Arccos() { return getToken(DataParser.Arccos, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ArccosContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitArccos(this);
else return visitor.visitChildren(this);
}
}
public static class NoContext extends ExprContext {
public TerminalNode No() { return getToken(DataParser.No, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode IsTrue() { return getToken(DataParser.IsTrue, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public NoContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNo(this);
else return visitor.visitChildren(this);
}
}
public static class FirstFromContext extends ExprContext {
public TerminalNode First() { return getToken(DataParser.First, 0); }
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public FirstFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitFirstFrom(this);
else return visitor.visitChildren(this);
}
}
public static class AsStringContext extends ExprContext {
public TerminalNode AsString() { return getToken(DataParser.AsString, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public AsStringContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAsString(this);
else return visitor.visitChildren(this);
}
}
public static class DotContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public DotContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDot(this);
else return visitor.visitChildren(this);
}
}
public static class MinimumFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Min() { return getToken(DataParser.Min, 0); }
public MinimumFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMinimumFrom(this);
else return visitor.visitChildren(this);
}
}
public static class MatchesContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode MatchesPattern() { return getToken(DataParser.MatchesPattern, 0); }
public MatchesContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMatches(this);
else return visitor.visitChildren(this);
}
}
public static class AbsContext extends ExprContext {
public TerminalNode Abs() { return getToken(DataParser.Abs, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public AbsContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAbs(this);
else return visitor.visitChildren(this);
}
}
public static class IndexOfFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Index() { return getToken(DataParser.Index, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public IndexOfFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIndexOfFrom(this);
else return visitor.visitChildren(this);
}
}
public static class IsInContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode In() { return getToken(DataParser.In, 0); }
public IsInContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsIn(this);
else return visitor.visitChildren(this);
}
}
public static class SubstringContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode StartingAt() { return getToken(DataParser.StartingAt, 0); }
public TerminalNode Substring() { return getToken(DataParser.Substring, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Characters() { return getToken(DataParser.Characters, 0); }
public SubstringContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSubstring(this);
else return visitor.visitChildren(this);
}
}
public static class ElementContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ElementContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitElement(this);
else return visitor.visitChildren(this);
}
}
public static class CloneContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Clone() { return getToken(DataParser.Clone, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public CloneContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitClone(this);
else return visitor.visitChildren(this);
}
}
public static class OccurEqualContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode At() { return getToken(DataParser.At, 0); }
public TerminalNode Equal() { return getToken(DataParser.Equal, 0); }
public OccurEqualContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurEqual(this);
else return visitor.visitChildren(this);
}
}
public static class IsWithinFollowingContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Following() { return getToken(DataParser.Following, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public IsWithinFollowingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsWithinFollowing(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryMinusContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Minus() { return getToken(DataParser.Minus, 0); }
public UnaryMinusContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitUnaryMinus(this);
else return visitor.visitChildren(this);
}
}
public static class OrContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Or() { return getToken(DataParser.Or, 0); }
public OrContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOr(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryListContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public UnaryListContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitUnaryList(this);
else return visitor.visitChildren(this);
}
}
public static class ParensContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ParensContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitParens(this);
else return visitor.visitChildren(this);
}
}
public static class LogContext extends ExprContext {
public TerminalNode Log() { return getToken(DataParser.Log, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public LogContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLog(this);
else return visitor.visitChildren(this);
}
}
public static class AtMostOrLeastContext extends ExprContext {
public TerminalNode AreTrue() { return getToken(DataParser.AreTrue, 0); }
public TerminalNode Least() { return getToken(DataParser.Least, 0); }
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode At() { return getToken(DataParser.At, 0); }
public TerminalNode IsTrue() { return getToken(DataParser.IsTrue, 0); }
public TerminalNode Most() { return getToken(DataParser.Most, 0); }
public AtMostOrLeastContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAtMostOrLeast(this);
else return visitor.visitChildren(this);
}
}
public static class ExtractContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TemporalUnitContext temporalUnit() {
return getRuleContext(TemporalUnitContext.class,0);
}
public TerminalNode Extract() { return getToken(DataParser.Extract, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ExtractContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitExtract(this);
else return visitor.visitChildren(this);
}
}
public static class TimeOfDayValContext extends ExprContext {
public TerminalNode TimeOfDayVal() { return getToken(DataParser.TimeOfDayVal, 0); }
public TimeOfDayValContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTimeOfDayVal(this);
else return visitor.visitChildren(this);
}
}
public static class NotContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public NotContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNot(this);
else return visitor.visitChildren(this);
}
}
public static class MedianContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Median() { return getToken(DataParser.Median, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public MedianContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMedian(this);
else return visitor.visitChildren(this);
}
}
public static class FloorContext extends ExprContext {
public TerminalNode Floor() { return getToken(DataParser.Floor, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Int() { return getToken(DataParser.Int, 0); }
public FloorContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitFloor(this);
else return visitor.visitChildren(this);
}
}
public static class NowContext extends ExprContext {
public TerminalNode Now() { return getToken(DataParser.Now, 0); }
public NowContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNow(this);
else return visitor.visitChildren(this);
}
}
public static class TruncateContext extends ExprContext {
public TerminalNode Truncate() { return getToken(DataParser.Truncate, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TruncateContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTruncate(this);
else return visitor.visitChildren(this);
}
}
public static class IsLessThanOrEqualContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode LessThanOrEqual() { return getToken(DataParser.LessThanOrEqual, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IsLessThanOrEqualContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsLessThanOrEqual(this);
else return visitor.visitChildren(this);
}
}
public static class NullValContext extends ExprContext {
public TerminalNode Null() { return getToken(DataParser.Null, 0); }
public NullValContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNullVal(this);
else return visitor.visitChildren(this);
}
}
public static class OccurBeforeContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Before() { return getToken(DataParser.Before, 0); }
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public OccurBeforeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurBefore(this);
else return visitor.visitChildren(this);
}
}
public static class WhereTimeIsPresentContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode WhereTimePresent() { return getToken(DataParser.WhereTimePresent, 0); }
public WhereTimeIsPresentContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitWhereTimeIsPresent(this);
else return visitor.visitChildren(this);
}
}
public static class SortContext extends ExprContext {
public TerminalNode Sort() { return getToken(DataParser.Sort, 0); }
public TerminalNode Time() { return getToken(DataParser.Time, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Data() { return getToken(DataParser.Data, 0); }
public SortContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSort(this);
else return visitor.visitChildren(this);
}
}
public static class IntervalContext extends ExprContext {
public TerminalNode Interval() { return getToken(DataParser.Interval, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public IntervalContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitInterval(this);
else return visitor.visitChildren(this);
}
}
public static class MinimumContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Min() { return getToken(DataParser.Min, 0); }
public MinimumContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMinimum(this);
else return visitor.visitChildren(this);
}
}
public static class BeforeContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Before() { return getToken(DataParser.Before, 0); }
public BeforeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitBefore(this);
else return visitor.visitChildren(this);
}
}
public static class MergeContext extends ExprContext {
public TerminalNode Merge() { return getToken(DataParser.Merge, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public MergeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMerge(this);
else return visitor.visitChildren(this);
}
}
public static class IsLessThanContext extends ExprContext {
public TerminalNode LessThan() { return getToken(DataParser.LessThan, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IsLessThanContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsLessThan(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryPlusContext extends ExprContext {
public TerminalNode Plus() { return getToken(DataParser.Plus, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public UnaryPlusContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitUnaryPlus(this);
else return visitor.visitChildren(this);
}
}
public static class IsBeforeContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Before() { return getToken(DataParser.Before, 0); }
public IsBeforeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsBefore(this);
else return visitor.visitChildren(this);
}
}
public static class AddToListContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode To() { return getToken(DataParser.To, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode At() { return getToken(DataParser.At, 0); }
public TerminalNode Add() { return getToken(DataParser.Add, 0); }
public AddToListContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAddToList(this);
else return visitor.visitChildren(this);
}
}
public static class LengthContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Length() { return getToken(DataParser.Length, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public LengthContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLength(this);
else return visitor.visitChildren(this);
}
}
public static class AtTimeContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode AtTime() { return getToken(DataParser.AtTime, 0); }
public AtTimeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAtTime(this);
else return visitor.visitChildren(this);
}
}
public static class EarliestFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Earliest() { return getToken(DataParser.Earliest, 0); }
public EarliestFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitEarliestFrom(this);
else return visitor.visitChildren(this);
}
}
public static class OccurWithinFollowingContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode Following() { return getToken(DataParser.Following, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public OccurWithinFollowingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurWithinFollowing(this);
else return visitor.visitChildren(this);
}
}
public static class OccurWithinPrecedingContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public TerminalNode Preceding() { return getToken(DataParser.Preceding, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public OccurWithinPrecedingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurWithinPreceding(this);
else return visitor.visitChildren(this);
}
}
public static class ReverseContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Reverse() { return getToken(DataParser.Reverse, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ReverseContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitReverse(this);
else return visitor.visitChildren(this);
}
}
public static class IsDataTypeContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public IsDataTypeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsDataType(this);
else return visitor.visitChildren(this);
}
}
public static class ArctanContext extends ExprContext {
public TerminalNode Arctan() { return getToken(DataParser.Arctan, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ArctanContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitArctan(this);
else return visitor.visitChildren(this);
}
}
public static class SqrtContext extends ExprContext {
public TerminalNode Sqrt() { return getToken(DataParser.Sqrt, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public SqrtContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSqrt(this);
else return visitor.visitChildren(this);
}
}
public static class OccurWithinPastContext extends ExprContext {
public TerminalNode The() { return getToken(DataParser.The, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Past() { return getToken(DataParser.Past, 0); }
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public OccurWithinPastContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurWithinPast(this);
else return visitor.visitChildren(this);
}
}
public static class AsNumberContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode AsNumber() { return getToken(DataParser.AsNumber, 0); }
public AsNumberContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAsNumber(this);
else return visitor.visitChildren(this);
}
}
public static class DivideContext extends ExprContext {
public TerminalNode Div() { return getToken(DataParser.Div, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public DivideContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDivide(this);
else return visitor.visitChildren(this);
}
}
public static class StringValContext extends ExprContext {
public TerminalNode StringVal() { return getToken(DataParser.StringVal, 0); }
public StringValContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitStringVal(this);
else return visitor.visitChildren(this);
}
}
public static class ReplaceContext extends ExprContext {
public TerminalNode With() { return getToken(DataParser.With, 0); }
public TerminalNode Replace() { return getToken(DataParser.Replace, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TemporalUnitContext temporalUnit() {
return getRuleContext(TemporalUnitContext.class,0);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ReplaceContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitReplace(this);
else return visitor.visitChildren(this);
}
}
public static class ArcsinContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Arcsin() { return getToken(DataParser.Arcsin, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ArcsinContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitArcsin(this);
else return visitor.visitChildren(this);
}
}
public static class IsWithinToContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public TerminalNode To() { return getToken(DataParser.To, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public IsWithinToContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsWithinTo(this);
else return visitor.visitChildren(this);
}
}
public static class MaximumFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Max() { return getToken(DataParser.Max, 0); }
public MaximumFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMaximumFrom(this);
else return visitor.visitChildren(this);
}
}
public static class IsWithinSurroundingContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public TerminalNode Surrounding() { return getToken(DataParser.Surrounding, 0); }
public IsWithinSurroundingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsWithinSurrounding(this);
else return visitor.visitChildren(this);
}
}
public static class IsObjectTypeContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IsObjectTypeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsObjectType(this);
else return visitor.visitChildren(this);
}
}
public static class AgoContext extends ExprContext {
public TerminalNode Ago() { return getToken(DataParser.Ago, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public AgoContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAgo(this);
else return visitor.visitChildren(this);
}
}
public static class DecreaseContext extends ExprContext {
public TerminalNode Percent() { return getToken(DataParser.Percent, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Decrease() { return getToken(DataParser.Decrease, 0); }
public DecreaseContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDecrease(this);
else return visitor.visitChildren(this);
}
}
public static class StdDevContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Stddev() { return getToken(DataParser.Stddev, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public StdDevContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitStdDev(this);
else return visitor.visitChildren(this);
}
}
public static class ExtractCharsContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Extract() { return getToken(DataParser.Extract, 0); }
public TerminalNode Characters() { return getToken(DataParser.Characters, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ExtractCharsContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitExtractChars(this);
else return visitor.visitChildren(this);
}
}
public static class CountContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Count() { return getToken(DataParser.Count, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public CountContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitCount(this);
else return visitor.visitChildren(this);
}
}
public static class LastContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Last() { return getToken(DataParser.Last, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public LastContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLast(this);
else return visitor.visitChildren(this);
}
}
public static class NumberValContext extends ExprContext {
public TerminalNode NumberVal() { return getToken(DataParser.NumberVal, 0); }
public NumberValContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNumberVal(this);
else return visitor.visitChildren(this);
}
}
public static class BooleanValContext extends ExprContext {
public TerminalNode BooleanVal() { return getToken(DataParser.BooleanVal, 0); }
public BooleanValContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitBooleanVal(this);
else return visitor.visitChildren(this);
}
}
public static class RoundContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Round() { return getToken(DataParser.Round, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public RoundContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitRound(this);
else return visitor.visitChildren(this);
}
}
public static class WhereContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Where() { return getToken(DataParser.Where, 0); }
public WhereContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitWhere(this);
else return visitor.visitChildren(this);
}
}
public static class IsWithinPrecedingContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public TerminalNode Preceding() { return getToken(DataParser.Preceding, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public IsWithinPrecedingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsWithinPreceding(this);
else return visitor.visitChildren(this);
}
}
public static class LastFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Last() { return getToken(DataParser.Last, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public LastFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLastFrom(this);
else return visitor.visitChildren(this);
}
}
public static class BinaryListContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public BinaryListContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitBinaryList(this);
else return visitor.visitChildren(this);
}
}
public static class IsAfterContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public TerminalNode After() { return getToken(DataParser.After, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IsAfterContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsAfter(this);
else return visitor.visitChildren(this);
}
}
public static class UppercaseContext extends ExprContext {
public TerminalNode Uppercase() { return getToken(DataParser.Uppercase, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public UppercaseContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitUppercase(this);
else return visitor.visitChildren(this);
}
}
public static class BuildStringContext extends ExprContext {
public TerminalNode String() { return getToken(DataParser.String, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public BuildStringContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitBuildString(this);
else return visitor.visitChildren(this);
}
}
public static class AfterContext extends ExprContext {
public TerminalNode After() { return getToken(DataParser.After, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AfterContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAfter(this);
else return visitor.visitChildren(this);
}
}
public static class OccurWithinToContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public TerminalNode To() { return getToken(DataParser.To, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public OccurWithinToContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurWithinTo(this);
else return visitor.visitChildren(this);
}
}
public static class EarliestContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Earliest() { return getToken(DataParser.Earliest, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public EarliestContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitEarliest(this);
else return visitor.visitChildren(this);
}
}
public static class OccurWithinSameDayContext extends ExprContext {
public TerminalNode SameDayAs() { return getToken(DataParser.SameDayAs, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public OccurWithinSameDayContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurWithinSameDay(this);
else return visitor.visitChildren(this);
}
}
public static class AnyContext extends ExprContext {
public TerminalNode Any() { return getToken(DataParser.Any, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode IsTrue() { return getToken(DataParser.IsTrue, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public AnyContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAny(this);
else return visitor.visitChildren(this);
}
}
public static class DayOfWeekFuncContext extends ExprContext {
public TerminalNode DayOfWeekFunc() { return getToken(DataParser.DayOfWeekFunc, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public DayOfWeekFuncContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDayOfWeekFunc(this);
else return visitor.visitChildren(this);
}
}
public static class IsWithinSameDayContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public TerminalNode SameDayAs() { return getToken(DataParser.SameDayAs, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public IsWithinSameDayContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsWithinSameDay(this);
else return visitor.visitChildren(this);
}
}
public static class SubListContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode StartingAt() { return getToken(DataParser.StartingAt, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Sublist() { return getToken(DataParser.Sublist, 0); }
public TerminalNode Elements() { return getToken(DataParser.Elements, 0); }
public SubListContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSubList(this);
else return visitor.visitChildren(this);
}
}
public static class IndexContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Index() { return getToken(DataParser.Index, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public IndexContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIndex(this);
else return visitor.visitChildren(this);
}
}
public static class LatestFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Latest() { return getToken(DataParser.Latest, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public LatestFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLatestFrom(this);
else return visitor.visitChildren(this);
}
}
public static class IndexFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Index() { return getToken(DataParser.Index, 0); }
public IndexTypeContext indexType() {
return getRuleContext(IndexTypeContext.class,0);
}
public IndexFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIndexFrom(this);
else return visitor.visitChildren(this);
}
}
public static class AndContext extends ExprContext {
public TerminalNode And() { return getToken(DataParser.And, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AndContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAnd(this);
else return visitor.visitChildren(this);
}
}
public static class IsGreaterThanOrEqualContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode GreaterThanOrEqual() { return getToken(DataParser.GreaterThanOrEqual, 0); }
public IsGreaterThanOrEqualContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsGreaterThanOrEqual(this);
else return visitor.visitChildren(this);
}
}
public static class ExtractAttrNamesContext extends ExprContext {
public TerminalNode Names() { return getToken(DataParser.Names, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Extract() { return getToken(DataParser.Extract, 0); }
public TerminalNode Attribute() { return getToken(DataParser.Attribute, 0); }
public ExtractAttrNamesContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitExtractAttrNames(this);
else return visitor.visitChildren(this);
}
}
public static class ExpContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Exp() { return getToken(DataParser.Exp, 0); }
public ExpContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitExp(this);
else return visitor.visitChildren(this);
}
}
public static class CeilingContext extends ExprContext {
public TerminalNode Ceiling() { return getToken(DataParser.Ceiling, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public CeilingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitCeiling(this);
else return visitor.visitChildren(this);
}
}
public static class SineContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Sine() { return getToken(DataParser.Sine, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public SineContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSine(this);
else return visitor.visitChildren(this);
}
}
public static class MaximumContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Max() { return getToken(DataParser.Max, 0); }
public MaximumContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMaximum(this);
else return visitor.visitChildren(this);
}
}
public static class IsEqualContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode EqualTo() { return getToken(DataParser.EqualTo, 0); }
public IsEqualContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsEqual(this);
else return visitor.visitChildren(this);
}
}
public static class TangentContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Tangent() { return getToken(DataParser.Tangent, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TangentContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTangent(this);
else return visitor.visitChildren(this);
}
}
public static class AsTimeContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode AsTime() { return getToken(DataParser.AsTime, 0); }
public AsTimeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAsTime(this);
else return visitor.visitChildren(this);
}
}
public static class IsGreaterThanContext extends ExprContext {
public TerminalNode GreaterThan() { return getToken(DataParser.GreaterThan, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IsGreaterThanContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsGreaterThan(this);
else return visitor.visitChildren(this);
}
}
public static class OccurAfterContext extends ExprContext {
public TerminalNode After() { return getToken(DataParser.After, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public OccurAfterContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurAfter(this);
else return visitor.visitChildren(this);
}
}
public static class SumContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Sum() { return getToken(DataParser.Sum, 0); }
public SumContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSum(this);
else return visitor.visitChildren(this);
}
}
public static class AddContext extends ExprContext {
public TerminalNode Plus() { return getToken(DataParser.Plus, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AddContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAdd(this);
else return visitor.visitChildren(this);
}
}
public static class SeqtoContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode SeqTo() { return getToken(DataParser.SeqTo, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public SeqtoContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSeqto(this);
else return visitor.visitChildren(this);
}
}
public static class TimeOfDayFuncContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode TimeOfDayFunc() { return getToken(DataParser.TimeOfDayFunc, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TimeOfDayFuncContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTimeOfDayFunc(this);
else return visitor.visitChildren(this);
}
}
public static class OccurWithinSurroundingContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Occur() { return getToken(DataParser.Occur, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public TerminalNode Surrounding() { return getToken(DataParser.Surrounding, 0); }
public OccurWithinSurroundingContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitOccurWithinSurrounding(this);
else return visitor.visitChildren(this);
}
}
public static class IdContext extends ExprContext {
public TerminalNode The() { return getToken(DataParser.The, 0); }
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public IdContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitId(this);
else return visitor.visitChildren(this);
}
}
public static class NewObjectContext extends ExprContext {
public ObjOrderedWithContext objOrderedWith() {
return getRuleContext(ObjOrderedWithContext.class,0);
}
public TerminalNode New() { return getToken(DataParser.New, 0); }
public ObjNamedWithContext objNamedWith() {
return getRuleContext(ObjNamedWithContext.class,0);
}
public TerminalNode ID() { return getToken(DataParser.ID, 0); }
public NewObjectContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNewObject(this);
else return visitor.visitChildren(this);
}
}
public static class AttributeFromContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Attribute() { return getToken(DataParser.Attribute, 0); }
public AttributeFromContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAttributeFrom(this);
else return visitor.visitChildren(this);
}
}
public static class LowercaseContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Lowercase() { return getToken(DataParser.Lowercase, 0); }
public LowercaseContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLowercase(this);
else return visitor.visitChildren(this);
}
}
public static class TimeValContext extends ExprContext {
public TerminalNode TimeVal() { return getToken(DataParser.TimeVal, 0); }
public TimeValContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTimeVal(this);
else return visitor.visitChildren(this);
}
}
public static class TrimContext extends ExprContext {
public TerminalNode Left() { return getToken(DataParser.Left, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Right() { return getToken(DataParser.Right, 0); }
public TerminalNode Trim() { return getToken(DataParser.Trim, 0); }
public TrimContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTrim(this);
else return visitor.visitChildren(this);
}
}
public static class ExistContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Exist() { return getToken(DataParser.Exist, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public ExistContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitExist(this);
else return visitor.visitChildren(this);
}
}
public static class DayOfWeekContext extends ExprContext {
public TerminalNode DayOfWeek() { return getToken(DataParser.DayOfWeek, 0); }
public DayOfWeekContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDayOfWeek(this);
else return visitor.visitChildren(this);
}
}
public static class AllContext extends ExprContext {
public TerminalNode AreTrue() { return getToken(DataParser.AreTrue, 0); }
public TerminalNode All() { return getToken(DataParser.All, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public AllContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAll(this);
else return visitor.visitChildren(this);
}
}
public static class CosineContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Cosine() { return getToken(DataParser.Cosine, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public CosineContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitCosine(this);
else return visitor.visitChildren(this);
}
}
public static class RemoveFromListContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Remove() { return getToken(DataParser.Remove, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public RemoveFromListContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitRemoveFromList(this);
else return visitor.visitChildren(this);
}
}
public static class MultiplyContext extends ExprContext {
public TerminalNode Mul() { return getToken(DataParser.Mul, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public MultiplyContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitMultiply(this);
else return visitor.visitChildren(this);
}
}
public static class VarianceContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Variance() { return getToken(DataParser.Variance, 0); }
public VarianceContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitVariance(this);
else return visitor.visitChildren(this);
}
}
public static class NearestContext extends ExprContext {
public TerminalNode From() { return getToken(DataParser.From, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Nearest() { return getToken(DataParser.Nearest, 0); }
public TerminalNode Index() { return getToken(DataParser.Index, 0); }
public NearestContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitNearest(this);
else return visitor.visitChildren(this);
}
}
public static class ConcatContext extends ExprContext {
public List Concat() { return getTokens(DataParser.Concat); }
public TerminalNode Concat(int i) {
return getToken(DataParser.Concat, i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ConcatContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitConcat(this);
else return visitor.visitChildren(this);
}
}
public static class EmptyListContext extends ExprContext {
public TerminalNode EmptyList() { return getToken(DataParser.EmptyList, 0); }
public EmptyListContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitEmptyList(this);
else return visitor.visitChildren(this);
}
}
public static class Log10Context extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Log10() { return getToken(DataParser.Log10, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public Log10Context(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLog10(this);
else return visitor.visitChildren(this);
}
}
public static class CurrentTimeContext extends ExprContext {
public TerminalNode CurrentTime() { return getToken(DataParser.CurrentTime, 0); }
public CurrentTimeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitCurrentTime(this);
else return visitor.visitChildren(this);
}
}
public static class SubtractContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Minus() { return getToken(DataParser.Minus, 0); }
public SubtractContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitSubtract(this);
else return visitor.visitChildren(this);
}
}
public static class DurationContext extends ExprContext {
public DurationExprContext durationExpr() {
return getRuleContext(DurationExprContext.class,0);
}
public DurationContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitDuration(this);
else return visitor.visitChildren(this);
}
}
public static class FindInStringContext extends ExprContext {
public TerminalNode String() { return getToken(DataParser.String, 0); }
public TerminalNode Find() { return getToken(DataParser.Find, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode StartingAt() { return getToken(DataParser.StartingAt, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode In() { return getToken(DataParser.In, 0); }
public FindInStringContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitFindInString(this);
else return visitor.visitChildren(this);
}
}
public static class IsNotEqualContext extends ExprContext {
public TerminalNode NotEqualTo() { return getToken(DataParser.NotEqualTo, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IsNotEqualContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsNotEqual(this);
else return visitor.visitChildren(this);
}
}
public static class IncreaseContext extends ExprContext {
public TerminalNode Percent() { return getToken(DataParser.Percent, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Increase() { return getToken(DataParser.Increase, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public IncreaseContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIncrease(this);
else return visitor.visitChildren(this);
}
}
public static class RaiseToPowerContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Pow() { return getToken(DataParser.Pow, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public RaiseToPowerContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitRaiseToPower(this);
else return visitor.visitChildren(this);
}
}
public static class TimeFuncContext extends ExprContext {
public TerminalNode Time() { return getToken(DataParser.Time, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TimeFuncContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitTimeFunc(this);
else return visitor.visitChildren(this);
}
}
public static class LatestContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Latest() { return getToken(DataParser.Latest, 0); }
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public LatestContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitLatest(this);
else return visitor.visitChildren(this);
}
}
public static class FirstContext extends ExprContext {
public TerminalNode First() { return getToken(DataParser.First, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public FirstContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitFirst(this);
else return visitor.visitChildren(this);
}
}
public static class IsWithinPastContext extends ExprContext {
public TerminalNode Is() { return getToken(DataParser.Is, 0); }
public TerminalNode The() { return getToken(DataParser.The, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public TerminalNode Not() { return getToken(DataParser.Not, 0); }
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode Past() { return getToken(DataParser.Past, 0); }
public TerminalNode Within() { return getToken(DataParser.Within, 0); }
public IsWithinPastContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitIsWithinPast(this);
else return visitor.visitChildren(this);
}
}
public static class AverageContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode Of() { return getToken(DataParser.Of, 0); }
public TerminalNode Avg() { return getToken(DataParser.Avg, 0); }
public AverageContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitAverage(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState, _p);
ExprContext _prevctx = _localctx;
int _startState = 68;
enterRecursionRule(_localctx, RULE_expr);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(851);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
_localctx = new CountContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(439); match(Count);
setState(441);
_la = _input.LA(1);
if (_la==Of) {
{
setState(440); match(Of);
}
}
setState(443); expr(126);
}
break;
case 2:
{
_localctx = new ExistContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(444); match(Exist);
setState(446);
_la = _input.LA(1);
if (_la==Of) {
{
setState(445); match(Of);
}
}
setState(448); expr(125);
}
break;
case 3:
{
_localctx = new AverageContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(449); match(Avg);
setState(451);
_la = _input.LA(1);
if (_la==Of) {
{
setState(450); match(Of);
}
}
setState(453); expr(124);
}
break;
case 4:
{
_localctx = new MedianContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(454); match(Median);
setState(456);
_la = _input.LA(1);
if (_la==Of) {
{
setState(455); match(Of);
}
}
setState(458); expr(123);
}
break;
case 5:
{
_localctx = new SumContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(459); match(Sum);
setState(461);
_la = _input.LA(1);
if (_la==Of) {
{
setState(460); match(Of);
}
}
setState(463); expr(122);
}
break;
case 6:
{
_localctx = new StdDevContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(464); match(Stddev);
setState(466);
_la = _input.LA(1);
if (_la==Of) {
{
setState(465); match(Of);
}
}
setState(468); expr(121);
}
break;
case 7:
{
_localctx = new VarianceContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(469); match(Variance);
setState(471);
_la = _input.LA(1);
if (_la==Of) {
{
setState(470); match(Of);
}
}
setState(473); expr(120);
}
break;
case 8:
{
_localctx = new AnyContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(474); match(Any);
setState(476);
_la = _input.LA(1);
if (_la==IsTrue) {
{
setState(475); match(IsTrue);
}
}
setState(479);
_la = _input.LA(1);
if (_la==Of) {
{
setState(478); match(Of);
}
}
setState(481); expr(119);
}
break;
case 9:
{
_localctx = new AllContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(482); match(All);
setState(484);
_la = _input.LA(1);
if (_la==AreTrue) {
{
setState(483); match(AreTrue);
}
}
setState(487);
_la = _input.LA(1);
if (_la==Of) {
{
setState(486); match(Of);
}
}
setState(489); expr(118);
}
break;
case 10:
{
_localctx = new NoContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(490); match(No);
setState(492);
_la = _input.LA(1);
if (_la==IsTrue) {
{
setState(491); match(IsTrue);
}
}
setState(495);
_la = _input.LA(1);
if (_la==Of) {
{
setState(494); match(Of);
}
}
setState(497); expr(117);
}
break;
case 11:
{
_localctx = new MinimumContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(498); match(Min);
setState(500);
_la = _input.LA(1);
if (_la==Of) {
{
setState(499); match(Of);
}
}
setState(502); expr(108);
}
break;
case 12:
{
_localctx = new MaximumContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(503); match(Max);
setState(505);
_la = _input.LA(1);
if (_la==Of) {
{
setState(504); match(Of);
}
}
setState(507); expr(107);
}
break;
case 13:
{
_localctx = new FirstContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(508); match(First);
setState(510);
_la = _input.LA(1);
if (_la==Of) {
{
setState(509); match(Of);
}
}
setState(512); expr(106);
}
break;
case 14:
{
_localctx = new LastContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(513); match(Last);
setState(515);
_la = _input.LA(1);
if (_la==Of) {
{
setState(514); match(Of);
}
}
setState(517); expr(105);
}
break;
case 15:
{
_localctx = new EarliestContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(518); match(Earliest);
setState(520);
_la = _input.LA(1);
if (_la==Of) {
{
setState(519); match(Of);
}
}
setState(522); expr(104);
}
break;
case 16:
{
_localctx = new LatestContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(523); match(Latest);
setState(525);
_la = _input.LA(1);
if (_la==Of) {
{
setState(524); match(Of);
}
}
setState(527); expr(103);
}
break;
case 17:
{
_localctx = new IndexContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(528); match(Index);
setState(529); indexType();
setState(531);
_la = _input.LA(1);
if (_la==Of) {
{
setState(530); match(Of);
}
}
setState(533); expr(98);
}
break;
case 18:
{
_localctx = new IncreaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(536);
_la = _input.LA(1);
if (_la==Percent) {
{
setState(535); match(Percent);
}
}
setState(538); match(Increase);
setState(540);
_la = _input.LA(1);
if (_la==Of) {
{
setState(539); match(Of);
}
}
setState(542); expr(97);
}
break;
case 19:
{
_localctx = new DecreaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(544);
_la = _input.LA(1);
if (_la==Percent) {
{
setState(543); match(Percent);
}
}
setState(546); match(Decrease);
setState(548);
_la = _input.LA(1);
if (_la==Of) {
{
setState(547); match(Of);
}
}
setState(550); expr(96);
}
break;
case 20:
{
_localctx = new IntervalContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(551); match(Interval);
setState(553);
_la = _input.LA(1);
if (_la==Of) {
{
setState(552); match(Of);
}
}
setState(555); expr(95);
}
break;
case 21:
{
_localctx = new TimeFuncContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(556); match(Time);
setState(558);
_la = _input.LA(1);
if (_la==Of) {
{
setState(557); match(Of);
}
}
setState(560); expr(94);
}
break;
case 22:
{
_localctx = new TimeOfDayFuncContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(561); match(TimeOfDayFunc);
setState(563);
_la = _input.LA(1);
if (_la==Of) {
{
setState(562); match(Of);
}
}
setState(565); expr(93);
}
break;
case 23:
{
_localctx = new DayOfWeekFuncContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(566); match(DayOfWeekFunc);
setState(568);
_la = _input.LA(1);
if (_la==Of) {
{
setState(567); match(Of);
}
}
setState(570); expr(92);
}
break;
case 24:
{
_localctx = new ArccosContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(571); match(Arccos);
setState(573);
_la = _input.LA(1);
if (_la==Of) {
{
setState(572); match(Of);
}
}
setState(575); expr(91);
}
break;
case 25:
{
_localctx = new ArcsinContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(576); match(Arcsin);
setState(578);
_la = _input.LA(1);
if (_la==Of) {
{
setState(577); match(Of);
}
}
setState(580); expr(90);
}
break;
case 26:
{
_localctx = new ArctanContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(581); match(Arctan);
setState(583);
_la = _input.LA(1);
if (_la==Of) {
{
setState(582); match(Of);
}
}
setState(585); expr(89);
}
break;
case 27:
{
_localctx = new CosineContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(586); match(Cosine);
setState(588);
_la = _input.LA(1);
if (_la==Of) {
{
setState(587); match(Of);
}
}
setState(590); expr(88);
}
break;
case 28:
{
_localctx = new SineContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(591); match(Sine);
setState(593);
_la = _input.LA(1);
if (_la==Of) {
{
setState(592); match(Of);
}
}
setState(595); expr(87);
}
break;
case 29:
{
_localctx = new TangentContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(596); match(Tangent);
setState(598);
_la = _input.LA(1);
if (_la==Of) {
{
setState(597); match(Of);
}
}
setState(600); expr(86);
}
break;
case 30:
{
_localctx = new ExpContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(601); match(Exp);
setState(603);
_la = _input.LA(1);
if (_la==Of) {
{
setState(602); match(Of);
}
}
setState(605); expr(85);
}
break;
case 31:
{
_localctx = new LogContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(606); match(Log);
setState(608);
_la = _input.LA(1);
if (_la==Of) {
{
setState(607); match(Of);
}
}
setState(610); expr(84);
}
break;
case 32:
{
_localctx = new Log10Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(611); match(Log10);
setState(613);
_la = _input.LA(1);
if (_la==Of) {
{
setState(612); match(Of);
}
}
setState(615); expr(83);
}
break;
case 33:
{
_localctx = new FloorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(616);
_la = _input.LA(1);
if ( !(_la==Int || _la==Floor) ) {
_errHandler.recoverInline(this);
}
consume();
setState(618);
_la = _input.LA(1);
if (_la==Of) {
{
setState(617); match(Of);
}
}
setState(620); expr(82);
}
break;
case 34:
{
_localctx = new CeilingContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(621); match(Ceiling);
setState(623);
_la = _input.LA(1);
if (_la==Of) {
{
setState(622); match(Of);
}
}
setState(625); expr(81);
}
break;
case 35:
{
_localctx = new TruncateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(626); match(Truncate);
setState(628);
_la = _input.LA(1);
if (_la==Of) {
{
setState(627); match(Of);
}
}
setState(630); expr(80);
}
break;
case 36:
{
_localctx = new RoundContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(631); match(Round);
setState(633);
_la = _input.LA(1);
if (_la==Of) {
{
setState(632); match(Of);
}
}
setState(635); expr(79);
}
break;
case 37:
{
_localctx = new AbsContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(636); match(Abs);
setState(638);
_la = _input.LA(1);
if (_la==Of) {
{
setState(637); match(Of);
}
}
setState(640); expr(78);
}
break;
case 38:
{
_localctx = new SqrtContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(641); match(Sqrt);
setState(643);
_la = _input.LA(1);
if (_la==Of) {
{
setState(642); match(Of);
}
}
setState(645); expr(77);
}
break;
case 39:
{
_localctx = new ExtractContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(646); match(Extract);
setState(647); temporalUnit();
setState(649);
_la = _input.LA(1);
if (_la==Of) {
{
setState(648); match(Of);
}
}
setState(651); expr(76);
}
break;
case 40:
{
_localctx = new ReverseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(653); match(Reverse);
setState(655);
_la = _input.LA(1);
if (_la==Of) {
{
setState(654); match(Of);
}
}
setState(657); expr(74);
}
break;
case 41:
{
_localctx = new ExtractCharsContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(658); match(Extract);
setState(659); match(Characters);
setState(661);
_la = _input.LA(1);
if (_la==Of) {
{
setState(660); match(Of);
}
}
setState(663); expr(73);
}
break;
case 42:
{
_localctx = new BuildStringContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(664); match(String);
setState(666);
_la = _input.LA(1);
if (_la==Of) {
{
setState(665); match(Of);
}
}
setState(668); expr(72);
}
break;
case 43:
{
_localctx = new LengthContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(669); match(Length);
setState(671);
_la = _input.LA(1);
if (_la==Of) {
{
setState(670); match(Of);
}
}
setState(673); expr(71);
}
break;
case 44:
{
_localctx = new ExtractAttrNamesContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(674); match(Extract);
setState(675); match(Attribute);
setState(676); match(Names);
setState(677); expr(69);
}
break;
case 45:
{
_localctx = new CloneContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(678); match(Clone);
setState(680);
_la = _input.LA(1);
if (_la==Of) {
{
setState(679); match(Of);
}
}
setState(682); expr(68);
}
break;
case 46:
{
_localctx = new UnaryPlusContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(683); match(Plus);
setState(684); expr(55);
}
break;
case 47:
{
_localctx = new UnaryMinusContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(685); match(Minus);
setState(686); expr(54);
}
break;
case 48:
{
_localctx = new UppercaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(687); match(Uppercase);
setState(688); expr(53);
}
break;
case 49:
{
_localctx = new LowercaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(689); match(Lowercase);
setState(690); expr(52);
}
break;
case 50:
{
_localctx = new TrimContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(691); match(Trim);
setState(693);
_la = _input.LA(1);
if (_la==Left || _la==Right) {
{
setState(692);
_la = _input.LA(1);
if ( !(_la==Left || _la==Right) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
setState(695); expr(51);
}
break;
case 51:
{
_localctx = new NotContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(696); match(Not);
setState(697); expr(22);
}
break;
case 52:
{
_localctx = new SortContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(698); match(Sort);
setState(700);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(699);
_la = _input.LA(1);
if ( !(_la==Time || _la==Data) ) {
_errHandler.recoverInline(this);
}
consume();
}
break;
}
setState(702); expr(16);
}
break;
case 53:
{
_localctx = new UnaryListContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(703); match(4);
setState(704); expr(13);
}
break;
case 54:
{
_localctx = new ParensContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(705); match(7);
push(true);
setState(707); expr(0);
pop();
setState(709); match(2);
}
break;
case 55:
{
_localctx = new MinimumFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(711); match(Min);
setState(712); expr(0);
setState(713); match(From);
setState(714); expr(0);
}
break;
case 56:
{
_localctx = new MaximumFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(716); match(Max);
setState(717); expr(0);
setState(718); match(From);
setState(719); expr(0);
}
break;
case 57:
{
_localctx = new EarliestFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(721); match(Earliest);
setState(722); expr(0);
setState(723); match(From);
setState(724); expr(0);
}
break;
case 58:
{
_localctx = new LatestFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(726); match(Latest);
setState(727); expr(0);
setState(728); match(From);
setState(729); expr(0);
}
break;
case 59:
{
_localctx = new FirstFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(731); match(First);
setState(732); expr(0);
setState(733); match(From);
setState(734); expr(0);
}
break;
case 60:
{
_localctx = new LastFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(736); match(Last);
setState(737); expr(0);
setState(738); match(From);
setState(739); expr(0);
}
break;
case 61:
{
_localctx = new NearestContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(742);
_la = _input.LA(1);
if (_la==Index) {
{
setState(741); match(Index);
}
}
setState(744); match(Nearest);
setState(745); expr(0);
setState(746); match(From);
setState(747); expr(0);
}
break;
case 62:
{
_localctx = new AtMostOrLeastContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(749); match(At);
setState(750);
_la = _input.LA(1);
if ( !(_la==Least || _la==Most) ) {
_errHandler.recoverInline(this);
}
consume();
setState(751); expr(0);
setState(753);
_la = _input.LA(1);
if (_la==IsTrue || _la==AreTrue) {
{
setState(752);
_la = _input.LA(1);
if ( !(_la==IsTrue || _la==AreTrue) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
setState(755); match(From);
setState(756); expr(0);
}
break;
case 63:
{
_localctx = new SubListContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(758); match(Sublist);
setState(759); expr(0);
setState(760); match(Elements);
setState(763);
_la = _input.LA(1);
if (_la==StartingAt) {
{
setState(761); match(StartingAt);
setState(762); expr(0);
}
}
setState(765); match(From);
setState(766); expr(0);
}
break;
case 64:
{
_localctx = new IndexOfFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(768); match(Index);
setState(769); match(Of);
setState(770); expr(0);
setState(771); match(From);
setState(772); expr(0);
}
break;
case 65:
{
_localctx = new IndexFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(774); match(Index);
setState(775); indexType();
setState(776); expr(0);
setState(777); match(From);
setState(778); expr(0);
}
break;
case 66:
{
_localctx = new ReplaceContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(780); match(Replace);
setState(781); temporalUnit();
setState(783);
_la = _input.LA(1);
if (_la==Of) {
{
setState(782); match(Of);
}
}
setState(785); expr(0);
setState(786); match(With);
setState(787); expr(0);
}
break;
case 67:
{
_localctx = new AttributeFromContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(789); match(Attribute);
setState(790); expr(0);
setState(791); match(From);
setState(792); expr(0);
}
break;
case 68:
{
_localctx = new FindInStringContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(794); match(Find);
setState(795); expr(0);
setState(797);
_la = _input.LA(1);
if (_la==In) {
{
setState(796); match(In);
}
}
setState(799); match(String);
setState(800); expr(0);
setState(803);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(801); match(StartingAt);
setState(802); expr(0);
}
break;
}
}
break;
case 69:
{
_localctx = new DurationContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(805); durationExpr();
}
break;
case 70:
{
_localctx = new SubstringContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(806); match(Substring);
setState(807); expr(0);
setState(808); match(Characters);
setState(811);
_la = _input.LA(1);
if (_la==StartingAt) {
{
setState(809); match(StartingAt);
setState(810); expr(0);
}
}
setState(813); match(From);
setState(814); expr(0);
}
break;
case 71:
{
_localctx = new AddToListContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(816); match(Add);
setState(817); expr(0);
setState(818); match(To);
setState(819); expr(0);
setState(822);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(820); match(At);
setState(821); expr(0);
}
break;
}
}
break;
case 72:
{
_localctx = new RemoveFromListContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(824); match(Remove);
setState(825); expr(0);
setState(826); match(From);
setState(827); expr(0);
}
break;
case 73:
{
_localctx = new NewObjectContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(829); match(New);
setState(830); match(ID);
setState(832);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(831); objOrderedWith();
}
break;
}
setState(835);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(834); objNamedWith();
}
break;
}
}
break;
case 74:
{
_localctx = new NumberValContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(837); match(NumberVal);
}
break;
case 75:
{
_localctx = new BooleanValContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(838); match(BooleanVal);
}
break;
case 76:
{
_localctx = new NowContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(839); match(Now);
}
break;
case 77:
{
_localctx = new CurrentTimeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(840); match(CurrentTime);
}
break;
case 78:
{
_localctx = new TimeValContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(841); match(TimeVal);
}
break;
case 79:
{
_localctx = new TimeOfDayValContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(842); match(TimeOfDayVal);
}
break;
case 80:
{
_localctx = new DayOfWeekContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(843); match(DayOfWeek);
}
break;
case 81:
{
_localctx = new NullValContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(844); match(Null);
}
break;
case 82:
{
_localctx = new StringValContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(845); match(StringVal);
}
break;
case 83:
{
_localctx = new IdContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(847);
_la = _input.LA(1);
if (_la==The) {
{
setState(846); match(The);
}
}
setState(849); match(ID);
}
break;
case 84:
{
_localctx = new EmptyListContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(850); match(EmptyList);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1122);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,127,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1120);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
_localctx = new SeqtoContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(853);
if (!(129 >= _localctx._p)) throw new FailedPredicateException(this, "129 >= $_p");
setState(854); match(SeqTo);
setState(855); expr(130);
}
break;
case 2:
{
_localctx = new MatchesContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(856);
if (!(65 >= _localctx._p)) throw new FailedPredicateException(this, "65 >= $_p");
setState(857); match(MatchesPattern);
setState(858); expr(66);
}
break;
case 3:
{
_localctx = new AtTimeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(859);
if (!(63 >= _localctx._p)) throw new FailedPredicateException(this, "63 >= $_p");
setState(860); match(AtTime);
setState(861); expr(64);
}
break;
case 4:
{
_localctx = new BeforeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(862);
if (!(62 >= _localctx._p)) throw new FailedPredicateException(this, "62 >= $_p");
setState(863); match(Before);
setState(864); expr(63);
}
break;
case 5:
{
_localctx = new AfterContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(865);
if (!(61 >= _localctx._p)) throw new FailedPredicateException(this, "61 >= $_p");
setState(866); match(After);
setState(867); expr(62);
}
break;
case 6:
{
_localctx = new RaiseToPowerContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(868);
if (!(60 >= _localctx._p)) throw new FailedPredicateException(this, "60 >= $_p");
setState(869); match(Pow);
setState(870); expr(61);
}
break;
case 7:
{
_localctx = new MultiplyContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(871);
if (!(59 >= _localctx._p)) throw new FailedPredicateException(this, "59 >= $_p");
setState(872); match(Mul);
setState(873); expr(60);
}
break;
case 8:
{
_localctx = new DivideContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(874);
if (!(58 >= _localctx._p)) throw new FailedPredicateException(this, "58 >= $_p");
setState(875); match(Div);
setState(876); expr(59);
}
break;
case 9:
{
_localctx = new AddContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(877);
if (!(57 >= _localctx._p)) throw new FailedPredicateException(this, "57 >= $_p");
setState(878); match(Plus);
setState(879); expr(58);
}
break;
case 10:
{
_localctx = new SubtractContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(880);
if (!(56 >= _localctx._p)) throw new FailedPredicateException(this, "56 >= $_p");
setState(881); match(Minus);
setState(882); expr(57);
}
break;
case 11:
{
_localctx = new IsEqualContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(883);
if (!(48 >= _localctx._p)) throw new FailedPredicateException(this, "48 >= $_p");
setState(884); match(EqualTo);
setState(885); expr(49);
}
break;
case 12:
{
_localctx = new IsNotEqualContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(886);
if (!(47 >= _localctx._p)) throw new FailedPredicateException(this, "47 >= $_p");
setState(887); match(NotEqualTo);
setState(888); expr(48);
}
break;
case 13:
{
_localctx = new IsLessThanContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(889);
if (!(46 >= _localctx._p)) throw new FailedPredicateException(this, "46 >= $_p");
setState(890); match(LessThan);
setState(891); expr(47);
}
break;
case 14:
{
_localctx = new IsLessThanOrEqualContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(892);
if (!(45 >= _localctx._p)) throw new FailedPredicateException(this, "45 >= $_p");
setState(893); match(LessThanOrEqual);
setState(894); expr(46);
}
break;
case 15:
{
_localctx = new IsGreaterThanOrEqualContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(895);
if (!(44 >= _localctx._p)) throw new FailedPredicateException(this, "44 >= $_p");
setState(896); match(GreaterThanOrEqual);
setState(897); expr(45);
}
break;
case 16:
{
_localctx = new IsGreaterThanContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(898);
if (!(43 >= _localctx._p)) throw new FailedPredicateException(this, "43 >= $_p");
setState(899); match(GreaterThan);
setState(900); expr(44);
}
break;
case 17:
{
_localctx = new AndContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(901);
if (!(21 >= _localctx._p)) throw new FailedPredicateException(this, "21 >= $_p");
setState(902); match(And);
setState(903); expr(22);
}
break;
case 18:
{
_localctx = new OrContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(904);
if (!(20 >= _localctx._p)) throw new FailedPredicateException(this, "20 >= $_p");
setState(905); match(Or);
setState(906); expr(21);
}
break;
case 19:
{
_localctx = new WhereContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(907);
if (!(19 >= _localctx._p)) throw new FailedPredicateException(this, "19 >= $_p");
setState(908); match(Where);
setState(909); expr(20);
}
break;
case 20:
{
_localctx = new MergeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(910);
if (!(14 >= _localctx._p)) throw new FailedPredicateException(this, "14 >= $_p");
setState(911); match(Merge);
setState(912); expr(15);
}
break;
case 21:
{
_localctx = new AsNumberContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(913);
if (!(132 >= _localctx._p)) throw new FailedPredicateException(this, "132 >= $_p");
setState(914); match(AsNumber);
}
break;
case 22:
{
_localctx = new AsTimeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(915);
if (!(131 >= _localctx._p)) throw new FailedPredicateException(this, "131 >= $_p");
setState(916); match(AsTime);
}
break;
case 23:
{
_localctx = new AsStringContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(917);
if (!(130 >= _localctx._p)) throw new FailedPredicateException(this, "130 >= $_p");
setState(918); match(AsString);
}
break;
case 24:
{
_localctx = new DotContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(919);
if (!(128 >= _localctx._p)) throw new FailedPredicateException(this, "128 >= $_p");
setState(920); match(3);
setState(921); match(ID);
}
break;
case 25:
{
_localctx = new ElementContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(922);
if (!(127 >= _localctx._p)) throw new FailedPredicateException(this, "127 >= $_p");
setState(923); match(6);
setState(924); expr(0);
setState(925); match(1);
}
break;
case 26:
{
_localctx = new WhereTimeIsPresentContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(927);
if (!(101 >= _localctx._p)) throw new FailedPredicateException(this, "101 >= $_p");
setState(928); match(WhereTimePresent);
}
break;
case 27:
{
_localctx = new AgoContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(929);
if (!(64 >= _localctx._p)) throw new FailedPredicateException(this, "64 >= $_p");
setState(930); match(Ago);
}
break;
case 28:
{
_localctx = new ConcatContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(931);
if (!(49 >= _localctx._p)) throw new FailedPredicateException(this, "49 >= $_p");
setState(934);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(932); match(Concat);
setState(933); expr(0);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(936);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
} while ( _alt!=2 && _alt!=-1 );
}
break;
case 29:
{
_localctx = new IsWithinToContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(938);
if (!(42 >= _localctx._p)) throw new FailedPredicateException(this, "42 >= $_p");
setState(939); match(Is);
setState(941);
_la = _input.LA(1);
if (_la==Not) {
{
setState(940); match(Not);
}
}
setState(943); match(Within);
setState(944); expr(0);
setState(945); match(To);
setState(946); expr(0);
}
break;
case 30:
{
_localctx = new IsWithinPrecedingContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(948);
if (!(41 >= _localctx._p)) throw new FailedPredicateException(this, "41 >= $_p");
setState(949); match(Is);
setState(951);
_la = _input.LA(1);
if (_la==Not) {
{
setState(950); match(Not);
}
}
setState(953); match(Within);
setState(954); expr(0);
setState(955); match(Preceding);
setState(956); expr(0);
}
break;
case 31:
{
_localctx = new IsWithinFollowingContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(958);
if (!(40 >= _localctx._p)) throw new FailedPredicateException(this, "40 >= $_p");
setState(959); match(Is);
setState(961);
_la = _input.LA(1);
if (_la==Not) {
{
setState(960); match(Not);
}
}
setState(963); match(Within);
setState(964); expr(0);
setState(965); match(Following);
setState(966); expr(0);
}
break;
case 32:
{
_localctx = new IsWithinSurroundingContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(968);
if (!(39 >= _localctx._p)) throw new FailedPredicateException(this, "39 >= $_p");
setState(969); match(Is);
setState(971);
_la = _input.LA(1);
if (_la==Not) {
{
setState(970); match(Not);
}
}
setState(973); match(Within);
setState(974); expr(0);
setState(975); match(Surrounding);
setState(976); expr(0);
}
break;
case 33:
{
_localctx = new IsWithinPastContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(978);
if (!(38 >= _localctx._p)) throw new FailedPredicateException(this, "38 >= $_p");
setState(979); match(Is);
setState(981);
_la = _input.LA(1);
if (_la==Not) {
{
setState(980); match(Not);
}
}
setState(983); match(Within);
setState(985);
_la = _input.LA(1);
if (_la==The) {
{
setState(984); match(The);
}
}
setState(987); match(Past);
setState(988); expr(0);
}
break;
case 34:
{
_localctx = new IsWithinSameDayContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(989);
if (!(37 >= _localctx._p)) throw new FailedPredicateException(this, "37 >= $_p");
setState(990); match(Is);
setState(992);
_la = _input.LA(1);
if (_la==Not) {
{
setState(991); match(Not);
}
}
setState(994); match(Within);
setState(995); match(SameDayAs);
setState(996); expr(0);
}
break;
case 35:
{
_localctx = new IsBeforeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(997);
if (!(36 >= _localctx._p)) throw new FailedPredicateException(this, "36 >= $_p");
setState(998); match(Is);
setState(1000);
_la = _input.LA(1);
if (_la==Not) {
{
setState(999); match(Not);
}
}
setState(1002); match(Before);
setState(1003); expr(0);
}
break;
case 36:
{
_localctx = new IsAfterContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1004);
if (!(35 >= _localctx._p)) throw new FailedPredicateException(this, "35 >= $_p");
setState(1005); match(Is);
setState(1007);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1006); match(Not);
}
}
setState(1009); match(After);
setState(1010); expr(0);
}
break;
case 37:
{
_localctx = new OccurEqualContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1011);
if (!(34 >= _localctx._p)) throw new FailedPredicateException(this, "34 >= $_p");
setState(1012); match(Occur);
setState(1014);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1013); match(Not);
}
}
setState(1016);
_la = _input.LA(1);
if ( !(_la==At || _la==Equal) ) {
_errHandler.recoverInline(this);
}
consume();
setState(1017); expr(0);
}
break;
case 38:
{
_localctx = new OccurWithinToContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1018);
if (!(33 >= _localctx._p)) throw new FailedPredicateException(this, "33 >= $_p");
setState(1019); match(Occur);
setState(1021);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1020); match(Not);
}
}
setState(1023); match(Within);
setState(1024); expr(0);
setState(1025); match(To);
setState(1026); expr(0);
}
break;
case 39:
{
_localctx = new OccurWithinPrecedingContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1028);
if (!(32 >= _localctx._p)) throw new FailedPredicateException(this, "32 >= $_p");
setState(1029); match(Occur);
setState(1031);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1030); match(Not);
}
}
setState(1033); match(Within);
setState(1034); expr(0);
setState(1035); match(Preceding);
setState(1036); expr(0);
}
break;
case 40:
{
_localctx = new OccurWithinFollowingContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1038);
if (!(31 >= _localctx._p)) throw new FailedPredicateException(this, "31 >= $_p");
setState(1039); match(Occur);
setState(1041);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1040); match(Not);
}
}
setState(1043); match(Within);
setState(1044); expr(0);
setState(1045); match(Following);
setState(1046); expr(0);
}
break;
case 41:
{
_localctx = new OccurWithinSurroundingContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1048);
if (!(30 >= _localctx._p)) throw new FailedPredicateException(this, "30 >= $_p");
setState(1049); match(Occur);
setState(1051);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1050); match(Not);
}
}
setState(1053); match(Within);
setState(1054); expr(0);
setState(1055); match(Surrounding);
setState(1056); expr(0);
}
break;
case 42:
{
_localctx = new OccurWithinPastContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1058);
if (!(29 >= _localctx._p)) throw new FailedPredicateException(this, "29 >= $_p");
setState(1059); match(Occur);
setState(1061);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1060); match(Not);
}
}
setState(1063); match(Within);
setState(1065);
_la = _input.LA(1);
if (_la==The) {
{
setState(1064); match(The);
}
}
setState(1067); match(Past);
setState(1068); expr(0);
}
break;
case 43:
{
_localctx = new OccurWithinSameDayContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1069);
if (!(28 >= _localctx._p)) throw new FailedPredicateException(this, "28 >= $_p");
setState(1070); match(Occur);
setState(1072);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1071); match(Not);
}
}
setState(1074); match(Within);
setState(1075); match(SameDayAs);
setState(1076); expr(0);
}
break;
case 44:
{
_localctx = new OccurBeforeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1077);
if (!(27 >= _localctx._p)) throw new FailedPredicateException(this, "27 >= $_p");
setState(1078); match(Occur);
setState(1080);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1079); match(Not);
}
}
setState(1082); match(Before);
setState(1083); expr(0);
}
break;
case 45:
{
_localctx = new OccurAfterContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1084);
if (!(26 >= _localctx._p)) throw new FailedPredicateException(this, "26 >= $_p");
setState(1085); match(Occur);
setState(1087);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1086); match(Not);
}
}
setState(1089); match(After);
setState(1090); expr(0);
}
break;
case 46:
{
_localctx = new IsInContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1091);
if (!(25 >= _localctx._p)) throw new FailedPredicateException(this, "25 >= $_p");
setState(1093);
_la = _input.LA(1);
if (_la==Is) {
{
setState(1092); match(Is);
}
}
setState(1096);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1095); match(Not);
}
}
setState(1098); match(In);
setState(1099); expr(0);
}
break;
case 47:
{
_localctx = new IsDataTypeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1100);
if (!(24 >= _localctx._p)) throw new FailedPredicateException(this, "24 >= $_p");
setState(1101); match(Is);
setState(1103);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1102); match(Not);
}
}
setState(1105); dataType();
}
break;
case 48:
{
_localctx = new IsObjectTypeContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1106);
if (!(23 >= _localctx._p)) throw new FailedPredicateException(this, "23 >= $_p");
setState(1107); match(Is);
setState(1109);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1108); match(Not);
}
break;
}
setState(1111); expr(0);
}
break;
case 49:
{
_localctx = new BinaryListContext(new ExprContext(_parentctx, _parentState, _p));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1112);
if (!(15 >= _localctx._p)) throw new FailedPredicateException(this, "15 >= $_p");
setState(1113);
if (!(list())) throw new FailedPredicateException(this, "list()");
setState(1116);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(1114); match(4);
setState(1115); expr(0);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1118);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
} while ( _alt!=2 && _alt!=-1 );
}
break;
}
}
}
setState(1124);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,127,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ObjOrderedWithContext extends ParserRuleContext {
public TerminalNode With() { return getToken(DataParser.With, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ObjOrderedWithContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objOrderedWith; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataVisitor ) return ((DataVisitor)visitor).visitObjOrderedWith(this);
else return visitor.visitChildren(this);
}
}
public final ObjOrderedWithContext objOrderedWith() throws RecognitionException {
ObjOrderedWithContext _localctx = new ObjOrderedWithContext(_ctx, getState());
enterRule(_localctx, 70, RULE_objOrderedWith);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
push(false);
setState(1126); match(With);
setState(1127); expr(0);
setState(1132);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1128); match(4);
setState(1129); expr(0);
}
}
}
setState(1134);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
}
pop();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjNamedWithContext extends ParserRuleContext {
public TerminalNode With() { return getToken(DataParser.With, 0); }
public List