org.kaazing.robot.lang.parser.v2.RobotParser Maven / Gradle / Ivy
The newest version!
// Generated from org/kaazing/robot/lang/parser/v2/Robot.g4 by ANTLR 4.2.2
package org.kaazing.robot.lang.parser.v2;
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 RobotParser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__11=1, T__10=2, T__9=3, T__8=4, T__7=5, T__6=6, T__5=7, T__4=8, T__3=9,
T__2=10, T__1=11, T__0=12, SignedDecimalLiteral=13, OptionKeyword=14,
MaskKeyword=15, ShortKeyword=16, IntKeyword=17, ByteKeyword=18, LongKeyword=19,
AcceptKeyword=20, AcceptedKeyword=21, AsKeyword=22, AwaitKeyword=23, BindKeyword=24,
BoundKeyword=25, ChildKeyword=26, CloseKeyword=27, ClosedKeyword=28, ConnectKeyword=29,
ConnectedKeyword=30, DisconnectKeyword=31, DisconnectedKeyword=32, NotifyKeyword=33,
OpenedKeyword=34, ReadKeyword=35, UnbindKeyword=36, UnboundKeyword=37,
WriteKeyword=38, HttpHeaderKeyword=39, HttpContentLengthKeyword=40, HttpMethodKeyword=41,
HttpParameterKeyword=42, HttpVersionKeyword=43, HttpStatusKeyword=44,
HttpResponseKeyword=45, HttpRequestKeyword=46, URILiteral=47, CaptureLiteral=48,
ExpressionLiteral=49, RegexLiteral=50, BytesLiteral=51, ByteLiteral=52,
TwoByteLiteral=53, Plus=54, Minus=55, DecimalLiteral=56, TextLiteral=57,
Name=58, WS=59, LineComment=60;
public static final String[] tokenNames = {
"", "'([0..'", "']'", "'}]'", "')'", "'(long'", "'(short'", "'[('",
"'){'", "'[0..'", "'(byte'", "'(int'", "'L'", "SignedDecimalLiteral",
"'option'", "'mask'", "'short'", "'int'", "'byte'", "'long'", "'accept'",
"'accepted'", "'as'", "'await'", "'bind'", "'bound'", "'child'", "'close'",
"'closed'", "'connect'", "'connected'", "'disconnect'", "'disconnected'",
"'notify'", "'opened'", "'read'", "'unbind'", "'unbound'", "'write'",
"'header'", "'content-length'", "'method'", "'parameter'", "'version'",
"'status'", "'response'", "'request'", "URILiteral", "CaptureLiteral",
"ExpressionLiteral", "RegexLiteral", "BytesLiteral", "ByteLiteral", "TwoByteLiteral",
"'+'", "'-'", "DecimalLiteral", "TextLiteral", "Name", "WS", "LineComment"
};
public static final int
RULE_scriptNode = 0, RULE_streamNode = 1, RULE_acceptNode = 2, RULE_acceptableNode = 3,
RULE_connectNode = 4, RULE_serverStreamableNode = 5, RULE_optionNode = 6,
RULE_writeOptionNode = 7, RULE_readOptionNode = 8, RULE_serverCommandNode = 9,
RULE_serverEventNode = 10, RULE_streamableNode = 11, RULE_commandNode = 12,
RULE_eventNode = 13, RULE_barrierNode = 14, RULE_closeNode = 15, RULE_writeCloseNode = 16,
RULE_disconnectNode = 17, RULE_unbindNode = 18, RULE_writeNode = 19, RULE_childOpenedNode = 20,
RULE_childClosedNode = 21, RULE_boundNode = 22, RULE_closedNode = 23,
RULE_connectedNode = 24, RULE_disconnectedNode = 25, RULE_openedNode = 26,
RULE_readClosedNode = 27, RULE_readNode = 28, RULE_unboundNode = 29, RULE_readAwaitNode = 30,
RULE_readNotifyNode = 31, RULE_writeAwaitNode = 32, RULE_writeNotifyNode = 33,
RULE_readHttpHeaderNode = 34, RULE_writeHttpHeaderNode = 35, RULE_writeHttpContentLengthNode = 36,
RULE_readHttpMethodNode = 37, RULE_writeHttpMethodNode = 38, RULE_readHttpParameterNode = 39,
RULE_writeHttpParameterNode = 40, RULE_readHttpVersionNode = 41, RULE_writeHttpVersionNode = 42,
RULE_readHttpStatusNode = 43, RULE_writeHttpStatusNode = 44, RULE_matcher = 45,
RULE_exactTextMatcher = 46, RULE_exactBytesMatcher = 47, RULE_regexMatcher = 48,
RULE_expressionMatcher = 49, RULE_fixedLengthBytesMatcher = 50, RULE_variableLengthBytesMatcher = 51,
RULE_writeValue = 52, RULE_literalText = 53, RULE_literalBytes = 54, RULE_expressionValue = 55;
public static final String[] ruleNames = {
"scriptNode", "streamNode", "acceptNode", "acceptableNode", "connectNode",
"serverStreamableNode", "optionNode", "writeOptionNode", "readOptionNode",
"serverCommandNode", "serverEventNode", "streamableNode", "commandNode",
"eventNode", "barrierNode", "closeNode", "writeCloseNode", "disconnectNode",
"unbindNode", "writeNode", "childOpenedNode", "childClosedNode", "boundNode",
"closedNode", "connectedNode", "disconnectedNode", "openedNode", "readClosedNode",
"readNode", "unboundNode", "readAwaitNode", "readNotifyNode", "writeAwaitNode",
"writeNotifyNode", "readHttpHeaderNode", "writeHttpHeaderNode", "writeHttpContentLengthNode",
"readHttpMethodNode", "writeHttpMethodNode", "readHttpParameterNode",
"writeHttpParameterNode", "readHttpVersionNode", "writeHttpVersionNode",
"readHttpStatusNode", "writeHttpStatusNode", "matcher", "exactTextMatcher",
"exactBytesMatcher", "regexMatcher", "expressionMatcher", "fixedLengthBytesMatcher",
"variableLengthBytesMatcher", "writeValue", "literalText", "literalBytes",
"expressionValue"
};
@Override
public String getGrammarFileName() { return "Robot.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public RobotParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ScriptNodeContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(RobotParser.EOF, 0); }
public List streamNode() {
return getRuleContexts(StreamNodeContext.class);
}
public StreamNodeContext streamNode(int i) {
return getRuleContext(StreamNodeContext.class,i);
}
public ScriptNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scriptNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterScriptNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitScriptNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitScriptNode(this);
else return visitor.visitChildren(this);
}
}
public final ScriptNodeContext scriptNode() throws RecognitionException {
ScriptNodeContext _localctx = new ScriptNodeContext(_ctx, getState());
enterRule(_localctx, 0, RULE_scriptNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(115);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AcceptKeyword) | (1L << AcceptedKeyword) | (1L << ConnectKeyword))) != 0)) {
{
{
setState(112); streamNode();
}
}
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(118); match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamNodeContext extends ParserRuleContext {
public AcceptNodeContext acceptNode() {
return getRuleContext(AcceptNodeContext.class,0);
}
public AcceptableNodeContext acceptableNode() {
return getRuleContext(AcceptableNodeContext.class,0);
}
public ConnectNodeContext connectNode() {
return getRuleContext(ConnectNodeContext.class,0);
}
public StreamNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_streamNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterStreamNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitStreamNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitStreamNode(this);
else return visitor.visitChildren(this);
}
}
public final StreamNodeContext streamNode() throws RecognitionException {
StreamNodeContext _localctx = new StreamNodeContext(_ctx, getState());
enterRule(_localctx, 2, RULE_streamNode);
try {
setState(123);
switch (_input.LA(1)) {
case AcceptKeyword:
enterOuterAlt(_localctx, 1);
{
setState(120); acceptNode();
}
break;
case AcceptedKeyword:
enterOuterAlt(_localctx, 2);
{
setState(121); acceptableNode();
}
break;
case ConnectKeyword:
enterOuterAlt(_localctx, 3);
{
setState(122); connectNode();
}
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 AcceptNodeContext extends ParserRuleContext {
public Token k;
public Token acceptURI;
public Token text;
public List serverStreamableNode() {
return getRuleContexts(ServerStreamableNodeContext.class);
}
public TerminalNode AsKeyword() { return getToken(RobotParser.AsKeyword, 0); }
public ServerStreamableNodeContext serverStreamableNode(int i) {
return getRuleContext(ServerStreamableNodeContext.class,i);
}
public TerminalNode Name() { return getToken(RobotParser.Name, 0); }
public TerminalNode AcceptKeyword() { return getToken(RobotParser.AcceptKeyword, 0); }
public TerminalNode URILiteral() { return getToken(RobotParser.URILiteral, 0); }
public AcceptNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_acceptNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterAcceptNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitAcceptNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitAcceptNode(this);
else return visitor.visitChildren(this);
}
}
public final AcceptNodeContext acceptNode() throws RecognitionException {
AcceptNodeContext _localctx = new AcceptNodeContext(_ctx, getState());
enterRule(_localctx, 4, RULE_acceptNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(125); ((AcceptNodeContext)_localctx).k = match(AcceptKeyword);
setState(126); ((AcceptNodeContext)_localctx).acceptURI = match(URILiteral);
setState(129);
_la = _input.LA(1);
if (_la==AsKeyword) {
{
setState(127); match(AsKeyword);
setState(128); ((AcceptNodeContext)_localctx).text = match(Name);
}
}
setState(134);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BoundKeyword) | (1L << ChildKeyword) | (1L << CloseKeyword) | (1L << ClosedKeyword) | (1L << OpenedKeyword) | (1L << ReadKeyword) | (1L << UnbindKeyword) | (1L << UnboundKeyword) | (1L << WriteKeyword))) != 0)) {
{
{
setState(131); serverStreamableNode();
}
}
setState(136);
_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 AcceptableNodeContext extends ParserRuleContext {
public Token k;
public Token text;
public TerminalNode AcceptedKeyword() { return getToken(RobotParser.AcceptedKeyword, 0); }
public TerminalNode Name() { return getToken(RobotParser.Name, 0); }
public StreamableNodeContext streamableNode(int i) {
return getRuleContext(StreamableNodeContext.class,i);
}
public List streamableNode() {
return getRuleContexts(StreamableNodeContext.class);
}
public AcceptableNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_acceptableNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterAcceptableNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitAcceptableNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitAcceptableNode(this);
else return visitor.visitChildren(this);
}
}
public final AcceptableNodeContext acceptableNode() throws RecognitionException {
AcceptableNodeContext _localctx = new AcceptableNodeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_acceptableNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(137); ((AcceptableNodeContext)_localctx).k = match(AcceptedKeyword);
setState(139);
_la = _input.LA(1);
if (_la==Name) {
{
setState(138); ((AcceptableNodeContext)_localctx).text = match(Name);
}
}
setState(142);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(141); streamableNode();
}
}
setState(144);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BoundKeyword) | (1L << CloseKeyword) | (1L << ClosedKeyword) | (1L << ConnectedKeyword) | (1L << DisconnectedKeyword) | (1L << OpenedKeyword) | (1L << ReadKeyword) | (1L << UnboundKeyword) | (1L << WriteKeyword))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConnectNodeContext extends ParserRuleContext {
public Token k;
public Token connectURI;
public TerminalNode ConnectKeyword() { return getToken(RobotParser.ConnectKeyword, 0); }
public StreamableNodeContext streamableNode(int i) {
return getRuleContext(StreamableNodeContext.class,i);
}
public TerminalNode URILiteral() { return getToken(RobotParser.URILiteral, 0); }
public List streamableNode() {
return getRuleContexts(StreamableNodeContext.class);
}
public ConnectNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_connectNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterConnectNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitConnectNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitConnectNode(this);
else return visitor.visitChildren(this);
}
}
public final ConnectNodeContext connectNode() throws RecognitionException {
ConnectNodeContext _localctx = new ConnectNodeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_connectNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(146); ((ConnectNodeContext)_localctx).k = match(ConnectKeyword);
setState(147); ((ConnectNodeContext)_localctx).connectURI = match(URILiteral);
setState(149);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(148); streamableNode();
}
}
setState(151);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BoundKeyword) | (1L << CloseKeyword) | (1L << ClosedKeyword) | (1L << ConnectedKeyword) | (1L << DisconnectedKeyword) | (1L << OpenedKeyword) | (1L << ReadKeyword) | (1L << UnboundKeyword) | (1L << WriteKeyword))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ServerStreamableNodeContext extends ParserRuleContext {
public OptionNodeContext optionNode() {
return getRuleContext(OptionNodeContext.class,0);
}
public BarrierNodeContext barrierNode() {
return getRuleContext(BarrierNodeContext.class,0);
}
public ServerCommandNodeContext serverCommandNode() {
return getRuleContext(ServerCommandNodeContext.class,0);
}
public ServerEventNodeContext serverEventNode() {
return getRuleContext(ServerEventNodeContext.class,0);
}
public ServerStreamableNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serverStreamableNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterServerStreamableNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitServerStreamableNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitServerStreamableNode(this);
else return visitor.visitChildren(this);
}
}
public final ServerStreamableNodeContext serverStreamableNode() throws RecognitionException {
ServerStreamableNodeContext _localctx = new ServerStreamableNodeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_serverStreamableNode);
try {
setState(157);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(153); barrierNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(154); serverEventNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(155); serverCommandNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(156); optionNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionNodeContext extends ParserRuleContext {
public WriteOptionNodeContext writeOptionNode() {
return getRuleContext(WriteOptionNodeContext.class,0);
}
public ReadOptionNodeContext readOptionNode() {
return getRuleContext(ReadOptionNodeContext.class,0);
}
public OptionNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterOptionNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitOptionNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitOptionNode(this);
else return visitor.visitChildren(this);
}
}
public final OptionNodeContext optionNode() throws RecognitionException {
OptionNodeContext _localctx = new OptionNodeContext(_ctx, getState());
enterRule(_localctx, 12, RULE_optionNode);
try {
setState(161);
switch (_input.LA(1)) {
case ReadKeyword:
enterOuterAlt(_localctx, 1);
{
setState(159); readOptionNode();
}
break;
case WriteKeyword:
enterOuterAlt(_localctx, 2);
{
setState(160); writeOptionNode();
}
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 WriteOptionNodeContext extends ParserRuleContext {
public Token k;
public Token name;
public WriteValueContext value;
public WriteValueContext writeValue() {
return getRuleContext(WriteValueContext.class,0);
}
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public TerminalNode MaskKeyword() { return getToken(RobotParser.MaskKeyword, 0); }
public TerminalNode OptionKeyword() { return getToken(RobotParser.OptionKeyword, 0); }
public WriteOptionNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeOptionNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteOptionNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteOptionNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteOptionNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteOptionNodeContext writeOptionNode() throws RecognitionException {
WriteOptionNodeContext _localctx = new WriteOptionNodeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_writeOptionNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(163); ((WriteOptionNodeContext)_localctx).k = match(WriteKeyword);
setState(164); match(OptionKeyword);
setState(165); ((WriteOptionNodeContext)_localctx).name = match(MaskKeyword);
setState(166); ((WriteOptionNodeContext)_localctx).value = writeValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadOptionNodeContext extends ParserRuleContext {
public Token k;
public Token name;
public WriteValueContext value;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public WriteValueContext writeValue() {
return getRuleContext(WriteValueContext.class,0);
}
public TerminalNode MaskKeyword() { return getToken(RobotParser.MaskKeyword, 0); }
public TerminalNode OptionKeyword() { return getToken(RobotParser.OptionKeyword, 0); }
public ReadOptionNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readOptionNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadOptionNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadOptionNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadOptionNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadOptionNodeContext readOptionNode() throws RecognitionException {
ReadOptionNodeContext _localctx = new ReadOptionNodeContext(_ctx, getState());
enterRule(_localctx, 16, RULE_readOptionNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(168); ((ReadOptionNodeContext)_localctx).k = match(ReadKeyword);
setState(169); match(OptionKeyword);
setState(170); ((ReadOptionNodeContext)_localctx).name = match(MaskKeyword);
setState(171); ((ReadOptionNodeContext)_localctx).value = writeValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ServerCommandNodeContext extends ParserRuleContext {
public CloseNodeContext closeNode() {
return getRuleContext(CloseNodeContext.class,0);
}
public UnbindNodeContext unbindNode() {
return getRuleContext(UnbindNodeContext.class,0);
}
public ServerCommandNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serverCommandNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterServerCommandNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitServerCommandNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitServerCommandNode(this);
else return visitor.visitChildren(this);
}
}
public final ServerCommandNodeContext serverCommandNode() throws RecognitionException {
ServerCommandNodeContext _localctx = new ServerCommandNodeContext(_ctx, getState());
enterRule(_localctx, 18, RULE_serverCommandNode);
try {
setState(175);
switch (_input.LA(1)) {
case UnbindKeyword:
enterOuterAlt(_localctx, 1);
{
setState(173); unbindNode();
}
break;
case CloseKeyword:
enterOuterAlt(_localctx, 2);
{
setState(174); closeNode();
}
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 ServerEventNodeContext extends ParserRuleContext {
public ChildClosedNodeContext childClosedNode() {
return getRuleContext(ChildClosedNodeContext.class,0);
}
public OpenedNodeContext openedNode() {
return getRuleContext(OpenedNodeContext.class,0);
}
public UnboundNodeContext unboundNode() {
return getRuleContext(UnboundNodeContext.class,0);
}
public ClosedNodeContext closedNode() {
return getRuleContext(ClosedNodeContext.class,0);
}
public ChildOpenedNodeContext childOpenedNode() {
return getRuleContext(ChildOpenedNodeContext.class,0);
}
public BoundNodeContext boundNode() {
return getRuleContext(BoundNodeContext.class,0);
}
public ServerEventNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serverEventNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterServerEventNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitServerEventNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitServerEventNode(this);
else return visitor.visitChildren(this);
}
}
public final ServerEventNodeContext serverEventNode() throws RecognitionException {
ServerEventNodeContext _localctx = new ServerEventNodeContext(_ctx, getState());
enterRule(_localctx, 20, RULE_serverEventNode);
try {
setState(183);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(177); openedNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(178); boundNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(179); childOpenedNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(180); childClosedNode();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(181); unboundNode();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(182); closedNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamableNodeContext extends ParserRuleContext {
public OptionNodeContext optionNode() {
return getRuleContext(OptionNodeContext.class,0);
}
public BarrierNodeContext barrierNode() {
return getRuleContext(BarrierNodeContext.class,0);
}
public CommandNodeContext commandNode() {
return getRuleContext(CommandNodeContext.class,0);
}
public EventNodeContext eventNode() {
return getRuleContext(EventNodeContext.class,0);
}
public StreamableNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_streamableNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterStreamableNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitStreamableNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitStreamableNode(this);
else return visitor.visitChildren(this);
}
}
public final StreamableNodeContext streamableNode() throws RecognitionException {
StreamableNodeContext _localctx = new StreamableNodeContext(_ctx, getState());
enterRule(_localctx, 22, RULE_streamableNode);
try {
setState(189);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(185); barrierNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(186); eventNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(187); commandNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(188); optionNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommandNodeContext extends ParserRuleContext {
public WriteHttpVersionNodeContext writeHttpVersionNode() {
return getRuleContext(WriteHttpVersionNodeContext.class,0);
}
public WriteHttpHeaderNodeContext writeHttpHeaderNode() {
return getRuleContext(WriteHttpHeaderNodeContext.class,0);
}
public WriteHttpStatusNodeContext writeHttpStatusNode() {
return getRuleContext(WriteHttpStatusNodeContext.class,0);
}
public WriteHttpMethodNodeContext writeHttpMethodNode() {
return getRuleContext(WriteHttpMethodNodeContext.class,0);
}
public WriteCloseNodeContext writeCloseNode() {
return getRuleContext(WriteCloseNodeContext.class,0);
}
public WriteHttpParameterNodeContext writeHttpParameterNode() {
return getRuleContext(WriteHttpParameterNodeContext.class,0);
}
public CloseNodeContext closeNode() {
return getRuleContext(CloseNodeContext.class,0);
}
public WriteHttpContentLengthNodeContext writeHttpContentLengthNode() {
return getRuleContext(WriteHttpContentLengthNodeContext.class,0);
}
public WriteNodeContext writeNode() {
return getRuleContext(WriteNodeContext.class,0);
}
public CommandNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commandNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterCommandNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitCommandNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitCommandNode(this);
else return visitor.visitChildren(this);
}
}
public final CommandNodeContext commandNode() throws RecognitionException {
CommandNodeContext _localctx = new CommandNodeContext(_ctx, getState());
enterRule(_localctx, 24, RULE_commandNode);
try {
setState(200);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(191); writeNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(192); writeCloseNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(193); closeNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(194); writeHttpHeaderNode();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(195); writeHttpContentLengthNode();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(196); writeHttpMethodNode();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(197); writeHttpParameterNode();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(198); writeHttpVersionNode();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(199); writeHttpStatusNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EventNodeContext extends ParserRuleContext {
public ReadClosedNodeContext readClosedNode() {
return getRuleContext(ReadClosedNodeContext.class,0);
}
public UnboundNodeContext unboundNode() {
return getRuleContext(UnboundNodeContext.class,0);
}
public ClosedNodeContext closedNode() {
return getRuleContext(ClosedNodeContext.class,0);
}
public ReadNodeContext readNode() {
return getRuleContext(ReadNodeContext.class,0);
}
public ReadHttpVersionNodeContext readHttpVersionNode() {
return getRuleContext(ReadHttpVersionNodeContext.class,0);
}
public ReadHttpStatusNodeContext readHttpStatusNode() {
return getRuleContext(ReadHttpStatusNodeContext.class,0);
}
public ReadHttpMethodNodeContext readHttpMethodNode() {
return getRuleContext(ReadHttpMethodNodeContext.class,0);
}
public DisconnectedNodeContext disconnectedNode() {
return getRuleContext(DisconnectedNodeContext.class,0);
}
public OpenedNodeContext openedNode() {
return getRuleContext(OpenedNodeContext.class,0);
}
public ReadHttpHeaderNodeContext readHttpHeaderNode() {
return getRuleContext(ReadHttpHeaderNodeContext.class,0);
}
public BoundNodeContext boundNode() {
return getRuleContext(BoundNodeContext.class,0);
}
public ConnectedNodeContext connectedNode() {
return getRuleContext(ConnectedNodeContext.class,0);
}
public ReadHttpParameterNodeContext readHttpParameterNode() {
return getRuleContext(ReadHttpParameterNodeContext.class,0);
}
public EventNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eventNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterEventNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitEventNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitEventNode(this);
else return visitor.visitChildren(this);
}
}
public final EventNodeContext eventNode() throws RecognitionException {
EventNodeContext _localctx = new EventNodeContext(_ctx, getState());
enterRule(_localctx, 26, RULE_eventNode);
try {
setState(215);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(202); openedNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(203); boundNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(204); readNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(205); readClosedNode();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(206); disconnectedNode();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(207); unboundNode();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(208); closedNode();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(209); connectedNode();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(210); readHttpHeaderNode();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(211); readHttpMethodNode();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(212); readHttpParameterNode();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(213); readHttpVersionNode();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(214); readHttpStatusNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BarrierNodeContext extends ParserRuleContext {
public WriteAwaitNodeContext writeAwaitNode() {
return getRuleContext(WriteAwaitNodeContext.class,0);
}
public WriteNotifyNodeContext writeNotifyNode() {
return getRuleContext(WriteNotifyNodeContext.class,0);
}
public ReadNotifyNodeContext readNotifyNode() {
return getRuleContext(ReadNotifyNodeContext.class,0);
}
public ReadAwaitNodeContext readAwaitNode() {
return getRuleContext(ReadAwaitNodeContext.class,0);
}
public BarrierNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_barrierNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterBarrierNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitBarrierNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitBarrierNode(this);
else return visitor.visitChildren(this);
}
}
public final BarrierNodeContext barrierNode() throws RecognitionException {
BarrierNodeContext _localctx = new BarrierNodeContext(_ctx, getState());
enterRule(_localctx, 28, RULE_barrierNode);
try {
setState(221);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(217); readAwaitNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(218); readNotifyNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(219); writeAwaitNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(220); writeNotifyNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CloseNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode CloseKeyword() { return getToken(RobotParser.CloseKeyword, 0); }
public CloseNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_closeNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterCloseNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitCloseNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitCloseNode(this);
else return visitor.visitChildren(this);
}
}
public final CloseNodeContext closeNode() throws RecognitionException {
CloseNodeContext _localctx = new CloseNodeContext(_ctx, getState());
enterRule(_localctx, 30, RULE_closeNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(223); ((CloseNodeContext)_localctx).k = match(CloseKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteCloseNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode CloseKeyword() { return getToken(RobotParser.CloseKeyword, 0); }
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public WriteCloseNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeCloseNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteCloseNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteCloseNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteCloseNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteCloseNodeContext writeCloseNode() throws RecognitionException {
WriteCloseNodeContext _localctx = new WriteCloseNodeContext(_ctx, getState());
enterRule(_localctx, 32, RULE_writeCloseNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(225); ((WriteCloseNodeContext)_localctx).k = match(WriteKeyword);
setState(226); match(CloseKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DisconnectNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode DisconnectKeyword() { return getToken(RobotParser.DisconnectKeyword, 0); }
public DisconnectNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_disconnectNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterDisconnectNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitDisconnectNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitDisconnectNode(this);
else return visitor.visitChildren(this);
}
}
public final DisconnectNodeContext disconnectNode() throws RecognitionException {
DisconnectNodeContext _localctx = new DisconnectNodeContext(_ctx, getState());
enterRule(_localctx, 34, RULE_disconnectNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(228); ((DisconnectNodeContext)_localctx).k = match(DisconnectKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnbindNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode UnbindKeyword() { return getToken(RobotParser.UnbindKeyword, 0); }
public UnbindNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unbindNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterUnbindNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitUnbindNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitUnbindNode(this);
else return visitor.visitChildren(this);
}
}
public final UnbindNodeContext unbindNode() throws RecognitionException {
UnbindNodeContext _localctx = new UnbindNodeContext(_ctx, getState());
enterRule(_localctx, 36, RULE_unbindNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(230); ((UnbindNodeContext)_localctx).k = match(UnbindKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteNodeContext extends ParserRuleContext {
public Token k;
public List writeValue() {
return getRuleContexts(WriteValueContext.class);
}
public WriteValueContext writeValue(int i) {
return getRuleContext(WriteValueContext.class,i);
}
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public WriteNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteNodeContext writeNode() throws RecognitionException {
WriteNodeContext _localctx = new WriteNodeContext(_ctx, getState());
enterRule(_localctx, 38, RULE_writeNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(232); ((WriteNodeContext)_localctx).k = match(WriteKeyword);
setState(234);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(233); writeValue();
}
}
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ExpressionLiteral) | (1L << BytesLiteral) | (1L << TextLiteral))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChildOpenedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode OpenedKeyword() { return getToken(RobotParser.OpenedKeyword, 0); }
public TerminalNode ChildKeyword() { return getToken(RobotParser.ChildKeyword, 0); }
public ChildOpenedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_childOpenedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterChildOpenedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitChildOpenedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitChildOpenedNode(this);
else return visitor.visitChildren(this);
}
}
public final ChildOpenedNodeContext childOpenedNode() throws RecognitionException {
ChildOpenedNodeContext _localctx = new ChildOpenedNodeContext(_ctx, getState());
enterRule(_localctx, 40, RULE_childOpenedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(238); ((ChildOpenedNodeContext)_localctx).k = match(ChildKeyword);
setState(239); match(OpenedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ChildClosedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode ClosedKeyword() { return getToken(RobotParser.ClosedKeyword, 0); }
public TerminalNode ChildKeyword() { return getToken(RobotParser.ChildKeyword, 0); }
public ChildClosedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_childClosedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterChildClosedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitChildClosedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitChildClosedNode(this);
else return visitor.visitChildren(this);
}
}
public final ChildClosedNodeContext childClosedNode() throws RecognitionException {
ChildClosedNodeContext _localctx = new ChildClosedNodeContext(_ctx, getState());
enterRule(_localctx, 42, RULE_childClosedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(241); ((ChildClosedNodeContext)_localctx).k = match(ChildKeyword);
setState(242); match(ClosedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BoundNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode BoundKeyword() { return getToken(RobotParser.BoundKeyword, 0); }
public BoundNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_boundNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterBoundNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitBoundNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitBoundNode(this);
else return visitor.visitChildren(this);
}
}
public final BoundNodeContext boundNode() throws RecognitionException {
BoundNodeContext _localctx = new BoundNodeContext(_ctx, getState());
enterRule(_localctx, 44, RULE_boundNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(244); ((BoundNodeContext)_localctx).k = match(BoundKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClosedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode ClosedKeyword() { return getToken(RobotParser.ClosedKeyword, 0); }
public ClosedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_closedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterClosedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitClosedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitClosedNode(this);
else return visitor.visitChildren(this);
}
}
public final ClosedNodeContext closedNode() throws RecognitionException {
ClosedNodeContext _localctx = new ClosedNodeContext(_ctx, getState());
enterRule(_localctx, 46, RULE_closedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(246); ((ClosedNodeContext)_localctx).k = match(ClosedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConnectedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode ConnectedKeyword() { return getToken(RobotParser.ConnectedKeyword, 0); }
public ConnectedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_connectedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterConnectedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitConnectedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitConnectedNode(this);
else return visitor.visitChildren(this);
}
}
public final ConnectedNodeContext connectedNode() throws RecognitionException {
ConnectedNodeContext _localctx = new ConnectedNodeContext(_ctx, getState());
enterRule(_localctx, 48, RULE_connectedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(248); ((ConnectedNodeContext)_localctx).k = match(ConnectedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DisconnectedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode DisconnectedKeyword() { return getToken(RobotParser.DisconnectedKeyword, 0); }
public DisconnectedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_disconnectedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterDisconnectedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitDisconnectedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitDisconnectedNode(this);
else return visitor.visitChildren(this);
}
}
public final DisconnectedNodeContext disconnectedNode() throws RecognitionException {
DisconnectedNodeContext _localctx = new DisconnectedNodeContext(_ctx, getState());
enterRule(_localctx, 50, RULE_disconnectedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(250); ((DisconnectedNodeContext)_localctx).k = match(DisconnectedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OpenedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode OpenedKeyword() { return getToken(RobotParser.OpenedKeyword, 0); }
public OpenedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_openedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterOpenedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitOpenedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitOpenedNode(this);
else return visitor.visitChildren(this);
}
}
public final OpenedNodeContext openedNode() throws RecognitionException {
OpenedNodeContext _localctx = new OpenedNodeContext(_ctx, getState());
enterRule(_localctx, 52, RULE_openedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(252); ((OpenedNodeContext)_localctx).k = match(OpenedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadClosedNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public TerminalNode ClosedKeyword() { return getToken(RobotParser.ClosedKeyword, 0); }
public ReadClosedNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readClosedNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadClosedNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadClosedNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadClosedNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadClosedNodeContext readClosedNode() throws RecognitionException {
ReadClosedNodeContext _localctx = new ReadClosedNodeContext(_ctx, getState());
enterRule(_localctx, 54, RULE_readClosedNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(254); ((ReadClosedNodeContext)_localctx).k = match(ReadKeyword);
setState(255); match(ClosedKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public MatcherContext matcher(int i) {
return getRuleContext(MatcherContext.class,i);
}
public List matcher() {
return getRuleContexts(MatcherContext.class);
}
public ReadNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadNodeContext readNode() throws RecognitionException {
ReadNodeContext _localctx = new ReadNodeContext(_ctx, getState());
enterRule(_localctx, 56, RULE_readNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(257); ((ReadNodeContext)_localctx).k = match(ReadKeyword);
setState(259);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(258); matcher();
}
}
setState(261);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << SignedDecimalLiteral) | (1L << ExpressionLiteral) | (1L << RegexLiteral) | (1L << BytesLiteral) | (1L << ByteLiteral) | (1L << TwoByteLiteral) | (1L << DecimalLiteral) | (1L << TextLiteral))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnboundNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode UnboundKeyword() { return getToken(RobotParser.UnboundKeyword, 0); }
public UnboundNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unboundNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterUnboundNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitUnboundNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitUnboundNode(this);
else return visitor.visitChildren(this);
}
}
public final UnboundNodeContext unboundNode() throws RecognitionException {
UnboundNodeContext _localctx = new UnboundNodeContext(_ctx, getState());
enterRule(_localctx, 58, RULE_unboundNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(263); ((UnboundNodeContext)_localctx).k = match(UnboundKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadAwaitNodeContext extends ParserRuleContext {
public Token k;
public Token barrier;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public TerminalNode Name() { return getToken(RobotParser.Name, 0); }
public TerminalNode AwaitKeyword() { return getToken(RobotParser.AwaitKeyword, 0); }
public ReadAwaitNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readAwaitNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadAwaitNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadAwaitNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadAwaitNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadAwaitNodeContext readAwaitNode() throws RecognitionException {
ReadAwaitNodeContext _localctx = new ReadAwaitNodeContext(_ctx, getState());
enterRule(_localctx, 60, RULE_readAwaitNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(265); ((ReadAwaitNodeContext)_localctx).k = match(ReadKeyword);
setState(266); match(AwaitKeyword);
setState(267); ((ReadAwaitNodeContext)_localctx).barrier = match(Name);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadNotifyNodeContext extends ParserRuleContext {
public Token k;
public Token barrier;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public TerminalNode Name() { return getToken(RobotParser.Name, 0); }
public TerminalNode NotifyKeyword() { return getToken(RobotParser.NotifyKeyword, 0); }
public ReadNotifyNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readNotifyNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadNotifyNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadNotifyNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadNotifyNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadNotifyNodeContext readNotifyNode() throws RecognitionException {
ReadNotifyNodeContext _localctx = new ReadNotifyNodeContext(_ctx, getState());
enterRule(_localctx, 62, RULE_readNotifyNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(269); ((ReadNotifyNodeContext)_localctx).k = match(ReadKeyword);
setState(270); match(NotifyKeyword);
setState(271); ((ReadNotifyNodeContext)_localctx).barrier = match(Name);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteAwaitNodeContext extends ParserRuleContext {
public Token k;
public Token barrier;
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public TerminalNode Name() { return getToken(RobotParser.Name, 0); }
public TerminalNode AwaitKeyword() { return getToken(RobotParser.AwaitKeyword, 0); }
public WriteAwaitNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeAwaitNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteAwaitNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteAwaitNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteAwaitNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteAwaitNodeContext writeAwaitNode() throws RecognitionException {
WriteAwaitNodeContext _localctx = new WriteAwaitNodeContext(_ctx, getState());
enterRule(_localctx, 64, RULE_writeAwaitNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(273); ((WriteAwaitNodeContext)_localctx).k = match(WriteKeyword);
setState(274); match(AwaitKeyword);
setState(275); ((WriteAwaitNodeContext)_localctx).barrier = match(Name);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteNotifyNodeContext extends ParserRuleContext {
public Token k;
public Token barrier;
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public TerminalNode Name() { return getToken(RobotParser.Name, 0); }
public TerminalNode NotifyKeyword() { return getToken(RobotParser.NotifyKeyword, 0); }
public WriteNotifyNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeNotifyNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteNotifyNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteNotifyNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteNotifyNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteNotifyNodeContext writeNotifyNode() throws RecognitionException {
WriteNotifyNodeContext _localctx = new WriteNotifyNodeContext(_ctx, getState());
enterRule(_localctx, 66, RULE_writeNotifyNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(277); ((WriteNotifyNodeContext)_localctx).k = match(WriteKeyword);
setState(278); match(NotifyKeyword);
setState(279); ((WriteNotifyNodeContext)_localctx).barrier = match(Name);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadHttpHeaderNodeContext extends ParserRuleContext {
public Token k;
public LiteralTextContext name;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public MatcherContext matcher(int i) {
return getRuleContext(MatcherContext.class,i);
}
public TerminalNode HttpHeaderKeyword() { return getToken(RobotParser.HttpHeaderKeyword, 0); }
public LiteralTextContext literalText() {
return getRuleContext(LiteralTextContext.class,0);
}
public List matcher() {
return getRuleContexts(MatcherContext.class);
}
public ReadHttpHeaderNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readHttpHeaderNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadHttpHeaderNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadHttpHeaderNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadHttpHeaderNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadHttpHeaderNodeContext readHttpHeaderNode() throws RecognitionException {
ReadHttpHeaderNodeContext _localctx = new ReadHttpHeaderNodeContext(_ctx, getState());
enterRule(_localctx, 68, RULE_readHttpHeaderNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(281); ((ReadHttpHeaderNodeContext)_localctx).k = match(ReadKeyword);
setState(282); match(HttpHeaderKeyword);
setState(283); ((ReadHttpHeaderNodeContext)_localctx).name = literalText();
setState(285);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(284); matcher();
}
}
setState(287);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << SignedDecimalLiteral) | (1L << ExpressionLiteral) | (1L << RegexLiteral) | (1L << BytesLiteral) | (1L << ByteLiteral) | (1L << TwoByteLiteral) | (1L << DecimalLiteral) | (1L << TextLiteral))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteHttpHeaderNodeContext extends ParserRuleContext {
public Token k;
public LiteralTextContext name;
public List writeValue() {
return getRuleContexts(WriteValueContext.class);
}
public WriteValueContext writeValue(int i) {
return getRuleContext(WriteValueContext.class,i);
}
public TerminalNode HttpHeaderKeyword() { return getToken(RobotParser.HttpHeaderKeyword, 0); }
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public LiteralTextContext literalText() {
return getRuleContext(LiteralTextContext.class,0);
}
public WriteHttpHeaderNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeHttpHeaderNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteHttpHeaderNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteHttpHeaderNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteHttpHeaderNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteHttpHeaderNodeContext writeHttpHeaderNode() throws RecognitionException {
WriteHttpHeaderNodeContext _localctx = new WriteHttpHeaderNodeContext(_ctx, getState());
enterRule(_localctx, 70, RULE_writeHttpHeaderNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(289); ((WriteHttpHeaderNodeContext)_localctx).k = match(WriteKeyword);
setState(290); match(HttpHeaderKeyword);
setState(291); ((WriteHttpHeaderNodeContext)_localctx).name = literalText();
setState(293);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(292); writeValue();
}
}
setState(295);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ExpressionLiteral) | (1L << BytesLiteral) | (1L << TextLiteral))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteHttpContentLengthNodeContext extends ParserRuleContext {
public Token k;
public TerminalNode HttpHeaderKeyword() { return getToken(RobotParser.HttpHeaderKeyword, 0); }
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public TerminalNode HttpContentLengthKeyword() { return getToken(RobotParser.HttpContentLengthKeyword, 0); }
public WriteHttpContentLengthNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeHttpContentLengthNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteHttpContentLengthNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteHttpContentLengthNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteHttpContentLengthNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteHttpContentLengthNodeContext writeHttpContentLengthNode() throws RecognitionException {
WriteHttpContentLengthNodeContext _localctx = new WriteHttpContentLengthNodeContext(_ctx, getState());
enterRule(_localctx, 72, RULE_writeHttpContentLengthNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(297); ((WriteHttpContentLengthNodeContext)_localctx).k = match(WriteKeyword);
setState(298); match(HttpHeaderKeyword);
setState(299); match(HttpContentLengthKeyword);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadHttpMethodNodeContext extends ParserRuleContext {
public Token k;
public MatcherContext method;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public TerminalNode HttpMethodKeyword() { return getToken(RobotParser.HttpMethodKeyword, 0); }
public MatcherContext matcher() {
return getRuleContext(MatcherContext.class,0);
}
public ReadHttpMethodNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readHttpMethodNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadHttpMethodNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadHttpMethodNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadHttpMethodNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadHttpMethodNodeContext readHttpMethodNode() throws RecognitionException {
ReadHttpMethodNodeContext _localctx = new ReadHttpMethodNodeContext(_ctx, getState());
enterRule(_localctx, 74, RULE_readHttpMethodNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(301); ((ReadHttpMethodNodeContext)_localctx).k = match(ReadKeyword);
setState(302); match(HttpMethodKeyword);
setState(303); ((ReadHttpMethodNodeContext)_localctx).method = matcher();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteHttpMethodNodeContext extends ParserRuleContext {
public Token k;
public WriteValueContext method;
public TerminalNode HttpMethodKeyword() { return getToken(RobotParser.HttpMethodKeyword, 0); }
public WriteValueContext writeValue() {
return getRuleContext(WriteValueContext.class,0);
}
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public WriteHttpMethodNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeHttpMethodNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteHttpMethodNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteHttpMethodNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteHttpMethodNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteHttpMethodNodeContext writeHttpMethodNode() throws RecognitionException {
WriteHttpMethodNodeContext _localctx = new WriteHttpMethodNodeContext(_ctx, getState());
enterRule(_localctx, 76, RULE_writeHttpMethodNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(305); ((WriteHttpMethodNodeContext)_localctx).k = match(WriteKeyword);
setState(306); match(HttpMethodKeyword);
setState(307); ((WriteHttpMethodNodeContext)_localctx).method = writeValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadHttpParameterNodeContext extends ParserRuleContext {
public Token k;
public LiteralTextContext name;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public MatcherContext matcher(int i) {
return getRuleContext(MatcherContext.class,i);
}
public TerminalNode HttpParameterKeyword() { return getToken(RobotParser.HttpParameterKeyword, 0); }
public LiteralTextContext literalText() {
return getRuleContext(LiteralTextContext.class,0);
}
public List matcher() {
return getRuleContexts(MatcherContext.class);
}
public ReadHttpParameterNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readHttpParameterNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadHttpParameterNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadHttpParameterNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadHttpParameterNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadHttpParameterNodeContext readHttpParameterNode() throws RecognitionException {
ReadHttpParameterNodeContext _localctx = new ReadHttpParameterNodeContext(_ctx, getState());
enterRule(_localctx, 78, RULE_readHttpParameterNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(309); ((ReadHttpParameterNodeContext)_localctx).k = match(ReadKeyword);
setState(310); match(HttpParameterKeyword);
setState(311); ((ReadHttpParameterNodeContext)_localctx).name = literalText();
setState(313);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(312); matcher();
}
}
setState(315);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << SignedDecimalLiteral) | (1L << ExpressionLiteral) | (1L << RegexLiteral) | (1L << BytesLiteral) | (1L << ByteLiteral) | (1L << TwoByteLiteral) | (1L << DecimalLiteral) | (1L << TextLiteral))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteHttpParameterNodeContext extends ParserRuleContext {
public Token k;
public LiteralTextContext name;
public List writeValue() {
return getRuleContexts(WriteValueContext.class);
}
public WriteValueContext writeValue(int i) {
return getRuleContext(WriteValueContext.class,i);
}
public TerminalNode HttpParameterKeyword() { return getToken(RobotParser.HttpParameterKeyword, 0); }
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public LiteralTextContext literalText() {
return getRuleContext(LiteralTextContext.class,0);
}
public WriteHttpParameterNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeHttpParameterNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteHttpParameterNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteHttpParameterNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteHttpParameterNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteHttpParameterNodeContext writeHttpParameterNode() throws RecognitionException {
WriteHttpParameterNodeContext _localctx = new WriteHttpParameterNodeContext(_ctx, getState());
enterRule(_localctx, 80, RULE_writeHttpParameterNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(317); ((WriteHttpParameterNodeContext)_localctx).k = match(WriteKeyword);
setState(318); match(HttpParameterKeyword);
setState(319); ((WriteHttpParameterNodeContext)_localctx).name = literalText();
setState(321);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(320); writeValue();
}
}
setState(323);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ExpressionLiteral) | (1L << BytesLiteral) | (1L << TextLiteral))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadHttpVersionNodeContext extends ParserRuleContext {
public Token k;
public MatcherContext version;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public TerminalNode HttpVersionKeyword() { return getToken(RobotParser.HttpVersionKeyword, 0); }
public MatcherContext matcher() {
return getRuleContext(MatcherContext.class,0);
}
public ReadHttpVersionNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readHttpVersionNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadHttpVersionNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadHttpVersionNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadHttpVersionNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadHttpVersionNodeContext readHttpVersionNode() throws RecognitionException {
ReadHttpVersionNodeContext _localctx = new ReadHttpVersionNodeContext(_ctx, getState());
enterRule(_localctx, 82, RULE_readHttpVersionNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(325); ((ReadHttpVersionNodeContext)_localctx).k = match(ReadKeyword);
setState(326); match(HttpVersionKeyword);
setState(327); ((ReadHttpVersionNodeContext)_localctx).version = matcher();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteHttpVersionNodeContext extends ParserRuleContext {
public Token k;
public WriteValueContext version;
public WriteValueContext writeValue() {
return getRuleContext(WriteValueContext.class,0);
}
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public TerminalNode HttpVersionKeyword() { return getToken(RobotParser.HttpVersionKeyword, 0); }
public WriteHttpVersionNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeHttpVersionNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteHttpVersionNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteHttpVersionNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteHttpVersionNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteHttpVersionNodeContext writeHttpVersionNode() throws RecognitionException {
WriteHttpVersionNodeContext _localctx = new WriteHttpVersionNodeContext(_ctx, getState());
enterRule(_localctx, 84, RULE_writeHttpVersionNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(329); ((WriteHttpVersionNodeContext)_localctx).k = match(WriteKeyword);
setState(330); match(HttpVersionKeyword);
setState(331); ((WriteHttpVersionNodeContext)_localctx).version = writeValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReadHttpStatusNodeContext extends ParserRuleContext {
public Token k;
public MatcherContext code;
public MatcherContext reason;
public TerminalNode ReadKeyword() { return getToken(RobotParser.ReadKeyword, 0); }
public TerminalNode HttpStatusKeyword() { return getToken(RobotParser.HttpStatusKeyword, 0); }
public MatcherContext matcher(int i) {
return getRuleContext(MatcherContext.class,i);
}
public List matcher() {
return getRuleContexts(MatcherContext.class);
}
public ReadHttpStatusNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_readHttpStatusNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterReadHttpStatusNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitReadHttpStatusNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitReadHttpStatusNode(this);
else return visitor.visitChildren(this);
}
}
public final ReadHttpStatusNodeContext readHttpStatusNode() throws RecognitionException {
ReadHttpStatusNodeContext _localctx = new ReadHttpStatusNodeContext(_ctx, getState());
enterRule(_localctx, 86, RULE_readHttpStatusNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(333); ((ReadHttpStatusNodeContext)_localctx).k = match(ReadKeyword);
setState(334); match(HttpStatusKeyword);
setState(335); ((ReadHttpStatusNodeContext)_localctx).code = matcher();
setState(336); ((ReadHttpStatusNodeContext)_localctx).reason = matcher();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteHttpStatusNodeContext extends ParserRuleContext {
public Token k;
public WriteValueContext code;
public WriteValueContext reason;
public List writeValue() {
return getRuleContexts(WriteValueContext.class);
}
public TerminalNode HttpStatusKeyword() { return getToken(RobotParser.HttpStatusKeyword, 0); }
public WriteValueContext writeValue(int i) {
return getRuleContext(WriteValueContext.class,i);
}
public TerminalNode WriteKeyword() { return getToken(RobotParser.WriteKeyword, 0); }
public WriteHttpStatusNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeHttpStatusNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteHttpStatusNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteHttpStatusNode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteHttpStatusNode(this);
else return visitor.visitChildren(this);
}
}
public final WriteHttpStatusNodeContext writeHttpStatusNode() throws RecognitionException {
WriteHttpStatusNodeContext _localctx = new WriteHttpStatusNodeContext(_ctx, getState());
enterRule(_localctx, 88, RULE_writeHttpStatusNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(338); ((WriteHttpStatusNodeContext)_localctx).k = match(WriteKeyword);
setState(339); match(HttpStatusKeyword);
setState(340); ((WriteHttpStatusNodeContext)_localctx).code = writeValue();
setState(341); ((WriteHttpStatusNodeContext)_localctx).reason = writeValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatcherContext extends ParserRuleContext {
public FixedLengthBytesMatcherContext fixedLengthBytesMatcher() {
return getRuleContext(FixedLengthBytesMatcherContext.class,0);
}
public ExactTextMatcherContext exactTextMatcher() {
return getRuleContext(ExactTextMatcherContext.class,0);
}
public RegexMatcherContext regexMatcher() {
return getRuleContext(RegexMatcherContext.class,0);
}
public ExactBytesMatcherContext exactBytesMatcher() {
return getRuleContext(ExactBytesMatcherContext.class,0);
}
public VariableLengthBytesMatcherContext variableLengthBytesMatcher() {
return getRuleContext(VariableLengthBytesMatcherContext.class,0);
}
public ExpressionMatcherContext expressionMatcher() {
return getRuleContext(ExpressionMatcherContext.class,0);
}
public MatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitMatcher(this);
else return visitor.visitChildren(this);
}
}
public final MatcherContext matcher() throws RecognitionException {
MatcherContext _localctx = new MatcherContext(_ctx, getState());
enterRule(_localctx, 90, RULE_matcher);
try {
setState(349);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(343); exactTextMatcher();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(344); exactBytesMatcher();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(345); regexMatcher();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(346); expressionMatcher();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(347); fixedLengthBytesMatcher();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(348); variableLengthBytesMatcher();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExactTextMatcherContext extends ParserRuleContext {
public Token text;
public TerminalNode TextLiteral() { return getToken(RobotParser.TextLiteral, 0); }
public ExactTextMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exactTextMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterExactTextMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitExactTextMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitExactTextMatcher(this);
else return visitor.visitChildren(this);
}
}
public final ExactTextMatcherContext exactTextMatcher() throws RecognitionException {
ExactTextMatcherContext _localctx = new ExactTextMatcherContext(_ctx, getState());
enterRule(_localctx, 92, RULE_exactTextMatcher);
try {
enterOuterAlt(_localctx, 1);
{
setState(351); ((ExactTextMatcherContext)_localctx).text = match(TextLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExactBytesMatcherContext extends ParserRuleContext {
public Token bytes;
public Token byteLiteral;
public Token shortLiteral;
public Token longLiteral;
public Token intLiteral;
public TerminalNode TwoByteLiteral() { return getToken(RobotParser.TwoByteLiteral, 0); }
public TerminalNode DecimalLiteral() { return getToken(RobotParser.DecimalLiteral, 0); }
public TerminalNode BytesLiteral() { return getToken(RobotParser.BytesLiteral, 0); }
public TerminalNode SignedDecimalLiteral() { return getToken(RobotParser.SignedDecimalLiteral, 0); }
public TerminalNode ByteLiteral() { return getToken(RobotParser.ByteLiteral, 0); }
public ExactBytesMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exactBytesMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterExactBytesMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitExactBytesMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitExactBytesMatcher(this);
else return visitor.visitChildren(this);
}
}
public final ExactBytesMatcherContext exactBytesMatcher() throws RecognitionException {
ExactBytesMatcherContext _localctx = new ExactBytesMatcherContext(_ctx, getState());
enterRule(_localctx, 94, RULE_exactBytesMatcher);
int _la;
try {
setState(359);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(353); ((ExactBytesMatcherContext)_localctx).bytes = match(BytesLiteral);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(354); ((ExactBytesMatcherContext)_localctx).byteLiteral = match(ByteLiteral);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(355); ((ExactBytesMatcherContext)_localctx).shortLiteral = match(TwoByteLiteral);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(356);
((ExactBytesMatcherContext)_localctx).longLiteral = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==SignedDecimalLiteral || _la==DecimalLiteral) ) {
((ExactBytesMatcherContext)_localctx).longLiteral = (Token)_errHandler.recoverInline(this);
}
consume();
setState(357); match(12);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(358);
((ExactBytesMatcherContext)_localctx).intLiteral = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==SignedDecimalLiteral || _la==DecimalLiteral) ) {
((ExactBytesMatcherContext)_localctx).intLiteral = (Token)_errHandler.recoverInline(this);
}
consume();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegexMatcherContext extends ParserRuleContext {
public Token regex;
public TerminalNode RegexLiteral() { return getToken(RobotParser.RegexLiteral, 0); }
public RegexMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterRegexMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitRegexMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitRegexMatcher(this);
else return visitor.visitChildren(this);
}
}
public final RegexMatcherContext regexMatcher() throws RecognitionException {
RegexMatcherContext _localctx = new RegexMatcherContext(_ctx, getState());
enterRule(_localctx, 96, RULE_regexMatcher);
try {
enterOuterAlt(_localctx, 1);
{
setState(361); ((RegexMatcherContext)_localctx).regex = match(RegexLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionMatcherContext extends ParserRuleContext {
public Token expression;
public TerminalNode ExpressionLiteral() { return getToken(RobotParser.ExpressionLiteral, 0); }
public ExpressionMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterExpressionMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitExpressionMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitExpressionMatcher(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionMatcherContext expressionMatcher() throws RecognitionException {
ExpressionMatcherContext _localctx = new ExpressionMatcherContext(_ctx, getState());
enterRule(_localctx, 98, RULE_expressionMatcher);
try {
enterOuterAlt(_localctx, 1);
{
setState(363); ((ExpressionMatcherContext)_localctx).expression = match(ExpressionLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FixedLengthBytesMatcherContext extends ParserRuleContext {
public Token lastIndex;
public Token capture;
public Token byteCapture;
public Token shortCapture;
public Token intCapture;
public Token longCapture;
public TerminalNode CaptureLiteral() { return getToken(RobotParser.CaptureLiteral, 0); }
public TerminalNode DecimalLiteral() { return getToken(RobotParser.DecimalLiteral, 0); }
public FixedLengthBytesMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fixedLengthBytesMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterFixedLengthBytesMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitFixedLengthBytesMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitFixedLengthBytesMatcher(this);
else return visitor.visitChildren(this);
}
}
public final FixedLengthBytesMatcherContext fixedLengthBytesMatcher() throws RecognitionException {
FixedLengthBytesMatcherContext _localctx = new FixedLengthBytesMatcherContext(_ctx, getState());
enterRule(_localctx, 100, RULE_fixedLengthBytesMatcher);
try {
setState(390);
switch (_input.LA(1)) {
case 9:
enterOuterAlt(_localctx, 1);
{
setState(365); match(9);
setState(366); ((FixedLengthBytesMatcherContext)_localctx).lastIndex = match(DecimalLiteral);
setState(367); match(2);
}
break;
case 1:
enterOuterAlt(_localctx, 2);
{
setState(368); match(1);
setState(369); ((FixedLengthBytesMatcherContext)_localctx).lastIndex = match(DecimalLiteral);
setState(370); match(2);
setState(371); ((FixedLengthBytesMatcherContext)_localctx).capture = match(CaptureLiteral);
setState(372); match(4);
}
break;
case 7:
enterOuterAlt(_localctx, 3);
{
setState(373); match(7);
setState(374); ((FixedLengthBytesMatcherContext)_localctx).capture = match(CaptureLiteral);
setState(375); match(8);
setState(376); ((FixedLengthBytesMatcherContext)_localctx).lastIndex = match(DecimalLiteral);
setState(377); match(3);
}
break;
case 10:
enterOuterAlt(_localctx, 4);
{
setState(378); match(10);
setState(379); ((FixedLengthBytesMatcherContext)_localctx).byteCapture = match(CaptureLiteral);
setState(380); match(4);
}
break;
case 6:
enterOuterAlt(_localctx, 5);
{
setState(381); match(6);
setState(382); ((FixedLengthBytesMatcherContext)_localctx).shortCapture = match(CaptureLiteral);
setState(383); match(4);
}
break;
case 11:
enterOuterAlt(_localctx, 6);
{
setState(384); match(11);
setState(385); ((FixedLengthBytesMatcherContext)_localctx).intCapture = match(CaptureLiteral);
setState(386); match(4);
}
break;
case 5:
enterOuterAlt(_localctx, 7);
{
setState(387); match(5);
setState(388); ((FixedLengthBytesMatcherContext)_localctx).longCapture = match(CaptureLiteral);
setState(389); match(4);
}
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 VariableLengthBytesMatcherContext extends ParserRuleContext {
public Token length;
public Token capture;
public TerminalNode ExpressionLiteral() { return getToken(RobotParser.ExpressionLiteral, 0); }
public TerminalNode CaptureLiteral() { return getToken(RobotParser.CaptureLiteral, 0); }
public VariableLengthBytesMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableLengthBytesMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterVariableLengthBytesMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitVariableLengthBytesMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitVariableLengthBytesMatcher(this);
else return visitor.visitChildren(this);
}
}
public final VariableLengthBytesMatcherContext variableLengthBytesMatcher() throws RecognitionException {
VariableLengthBytesMatcherContext _localctx = new VariableLengthBytesMatcherContext(_ctx, getState());
enterRule(_localctx, 102, RULE_variableLengthBytesMatcher);
try {
setState(400);
switch (_input.LA(1)) {
case 9:
enterOuterAlt(_localctx, 1);
{
setState(392); match(9);
setState(393); ((VariableLengthBytesMatcherContext)_localctx).length = match(ExpressionLiteral);
setState(394); match(2);
}
break;
case 1:
enterOuterAlt(_localctx, 2);
{
setState(395); match(1);
setState(396); ((VariableLengthBytesMatcherContext)_localctx).length = match(ExpressionLiteral);
setState(397); match(2);
setState(398); ((VariableLengthBytesMatcherContext)_localctx).capture = match(CaptureLiteral);
setState(399); match(4);
}
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 WriteValueContext extends ParserRuleContext {
public LiteralBytesContext literalBytes() {
return getRuleContext(LiteralBytesContext.class,0);
}
public ExpressionValueContext expressionValue() {
return getRuleContext(ExpressionValueContext.class,0);
}
public LiteralTextContext literalText() {
return getRuleContext(LiteralTextContext.class,0);
}
public WriteValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterWriteValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitWriteValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitWriteValue(this);
else return visitor.visitChildren(this);
}
}
public final WriteValueContext writeValue() throws RecognitionException {
WriteValueContext _localctx = new WriteValueContext(_ctx, getState());
enterRule(_localctx, 104, RULE_writeValue);
try {
setState(405);
switch (_input.LA(1)) {
case TextLiteral:
enterOuterAlt(_localctx, 1);
{
setState(402); literalText();
}
break;
case BytesLiteral:
enterOuterAlt(_localctx, 2);
{
setState(403); literalBytes();
}
break;
case ExpressionLiteral:
enterOuterAlt(_localctx, 3);
{
setState(404); expressionValue();
}
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 LiteralTextContext extends ParserRuleContext {
public Token text;
public TerminalNode TextLiteral() { return getToken(RobotParser.TextLiteral, 0); }
public LiteralTextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalText; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterLiteralText(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitLiteralText(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitLiteralText(this);
else return visitor.visitChildren(this);
}
}
public final LiteralTextContext literalText() throws RecognitionException {
LiteralTextContext _localctx = new LiteralTextContext(_ctx, getState());
enterRule(_localctx, 106, RULE_literalText);
try {
enterOuterAlt(_localctx, 1);
{
setState(407); ((LiteralTextContext)_localctx).text = match(TextLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralBytesContext extends ParserRuleContext {
public Token bytes;
public TerminalNode BytesLiteral() { return getToken(RobotParser.BytesLiteral, 0); }
public LiteralBytesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalBytes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterLiteralBytes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitLiteralBytes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitLiteralBytes(this);
else return visitor.visitChildren(this);
}
}
public final LiteralBytesContext literalBytes() throws RecognitionException {
LiteralBytesContext _localctx = new LiteralBytesContext(_ctx, getState());
enterRule(_localctx, 108, RULE_literalBytes);
try {
enterOuterAlt(_localctx, 1);
{
setState(409); ((LiteralBytesContext)_localctx).bytes = match(BytesLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionValueContext extends ParserRuleContext {
public Token expression;
public TerminalNode ExpressionLiteral() { return getToken(RobotParser.ExpressionLiteral, 0); }
public ExpressionValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).enterExpressionValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RobotListener ) ((RobotListener)listener).exitExpressionValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RobotVisitor ) return ((RobotVisitor)visitor).visitExpressionValue(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionValueContext expressionValue() throws RecognitionException {
ExpressionValueContext _localctx = new ExpressionValueContext(_ctx, getState());
enterRule(_localctx, 110, RULE_expressionValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(411); ((ExpressionValueContext)_localctx).expression = match(ExpressionLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3>\u01a0\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\3\2\7\2t\n\2\f\2\16\2w\13"+
"\2\3\2\3\2\3\3\3\3\3\3\5\3~\n\3\3\4\3\4\3\4\3\4\5\4\u0084\n\4\3\4\7\4"+
"\u0087\n\4\f\4\16\4\u008a\13\4\3\5\3\5\5\5\u008e\n\5\3\5\6\5\u0091\n\5"+
"\r\5\16\5\u0092\3\6\3\6\3\6\6\6\u0098\n\6\r\6\16\6\u0099\3\7\3\7\3\7\3"+
"\7\5\7\u00a0\n\7\3\b\3\b\5\b\u00a4\n\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n"+
"\3\n\3\n\3\13\3\13\5\13\u00b2\n\13\3\f\3\f\3\f\3\f\3\f\3\f\5\f\u00ba\n"+
"\f\3\r\3\r\3\r\3\r\5\r\u00c0\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
"\16\3\16\5\16\u00cb\n\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\3\17\5\17\u00da\n\17\3\20\3\20\3\20\3\20\5\20\u00e0\n"+
"\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\6\25\u00ed"+
"\n\25\r\25\16\25\u00ee\3\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\31\3"+
"\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\35\3\36\3\36\6\36\u0106"+
"\n\36\r\36\16\36\u0107\3\37\3\37\3 \3 \3 \3 \3!\3!\3!\3!\3\"\3\"\3\"\3"+
"\"\3#\3#\3#\3#\3$\3$\3$\3$\6$\u0120\n$\r$\16$\u0121\3%\3%\3%\3%\6%\u0128"+
"\n%\r%\16%\u0129\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3)\3)\3)\3)\6"+
")\u013c\n)\r)\16)\u013d\3*\3*\3*\3*\6*\u0144\n*\r*\16*\u0145\3+\3+\3+"+
"\3+\3,\3,\3,\3,\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\5/\u0160"+
"\n/\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u016a\n\61\3\62\3\62"+
"\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+
"\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\5\64"+
"\u0189\n\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u0193\n\65\3"+
"\66\3\66\3\66\5\66\u0198\n\66\3\67\3\67\38\38\39\39\39\2\2:\2\4\6\b\n"+
"\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\"+
"^`bdfhjlnp\2\3\4\2\17\17::\u01ab\2u\3\2\2\2\4}\3\2\2\2\6\177\3\2\2\2\b"+
"\u008b\3\2\2\2\n\u0094\3\2\2\2\f\u009f\3\2\2\2\16\u00a3\3\2\2\2\20\u00a5"+
"\3\2\2\2\22\u00aa\3\2\2\2\24\u00b1\3\2\2\2\26\u00b9\3\2\2\2\30\u00bf\3"+
"\2\2\2\32\u00ca\3\2\2\2\34\u00d9\3\2\2\2\36\u00df\3\2\2\2 \u00e1\3\2\2"+
"\2\"\u00e3\3\2\2\2$\u00e6\3\2\2\2&\u00e8\3\2\2\2(\u00ea\3\2\2\2*\u00f0"+
"\3\2\2\2,\u00f3\3\2\2\2.\u00f6\3\2\2\2\60\u00f8\3\2\2\2\62\u00fa\3\2\2"+
"\2\64\u00fc\3\2\2\2\66\u00fe\3\2\2\28\u0100\3\2\2\2:\u0103\3\2\2\2<\u0109"+
"\3\2\2\2>\u010b\3\2\2\2@\u010f\3\2\2\2B\u0113\3\2\2\2D\u0117\3\2\2\2F"+
"\u011b\3\2\2\2H\u0123\3\2\2\2J\u012b\3\2\2\2L\u012f\3\2\2\2N\u0133\3\2"+
"\2\2P\u0137\3\2\2\2R\u013f\3\2\2\2T\u0147\3\2\2\2V\u014b\3\2\2\2X\u014f"+
"\3\2\2\2Z\u0154\3\2\2\2\\\u015f\3\2\2\2^\u0161\3\2\2\2`\u0169\3\2\2\2"+
"b\u016b\3\2\2\2d\u016d\3\2\2\2f\u0188\3\2\2\2h\u0192\3\2\2\2j\u0197\3"+
"\2\2\2l\u0199\3\2\2\2n\u019b\3\2\2\2p\u019d\3\2\2\2rt\5\4\3\2sr\3\2\2"+
"\2tw\3\2\2\2us\3\2\2\2uv\3\2\2\2vx\3\2\2\2wu\3\2\2\2xy\7\2\2\3y\3\3\2"+
"\2\2z~\5\6\4\2{~\5\b\5\2|~\5\n\6\2}z\3\2\2\2}{\3\2\2\2}|\3\2\2\2~\5\3"+
"\2\2\2\177\u0080\7\26\2\2\u0080\u0083\7\61\2\2\u0081\u0082\7\30\2\2\u0082"+
"\u0084\7<\2\2\u0083\u0081\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0088\3\2"+
"\2\2\u0085\u0087\5\f\7\2\u0086\u0085\3\2\2\2\u0087\u008a\3\2\2\2\u0088"+
"\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\7\3\2\2\2\u008a\u0088\3\2\2\2"+
"\u008b\u008d\7\27\2\2\u008c\u008e\7<\2\2\u008d\u008c\3\2\2\2\u008d\u008e"+
"\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u0091\5\30\r\2\u0090\u008f\3\2\2\2"+
"\u0091\u0092\3\2\2\2\u0092\u0090\3\2\2\2\u0092\u0093\3\2\2\2\u0093\t\3"+
"\2\2\2\u0094\u0095\7\37\2\2\u0095\u0097\7\61\2\2\u0096\u0098\5\30\r\2"+
"\u0097\u0096\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u0097\3\2\2\2\u0099\u009a"+
"\3\2\2\2\u009a\13\3\2\2\2\u009b\u00a0\5\36\20\2\u009c\u00a0\5\26\f\2\u009d"+
"\u00a0\5\24\13\2\u009e\u00a0\5\16\b\2\u009f\u009b\3\2\2\2\u009f\u009c"+
"\3\2\2\2\u009f\u009d\3\2\2\2\u009f\u009e\3\2\2\2\u00a0\r\3\2\2\2\u00a1"+
"\u00a4\5\22\n\2\u00a2\u00a4\5\20\t\2\u00a3\u00a1\3\2\2\2\u00a3\u00a2\3"+
"\2\2\2\u00a4\17\3\2\2\2\u00a5\u00a6\7(\2\2\u00a6\u00a7\7\20\2\2\u00a7"+
"\u00a8\7\21\2\2\u00a8\u00a9\5j\66\2\u00a9\21\3\2\2\2\u00aa\u00ab\7%\2"+
"\2\u00ab\u00ac\7\20\2\2\u00ac\u00ad\7\21\2\2\u00ad\u00ae\5j\66\2\u00ae"+
"\23\3\2\2\2\u00af\u00b2\5&\24\2\u00b0\u00b2\5 \21\2\u00b1\u00af\3\2\2"+
"\2\u00b1\u00b0\3\2\2\2\u00b2\25\3\2\2\2\u00b3\u00ba\5\66\34\2\u00b4\u00ba"+
"\5.\30\2\u00b5\u00ba\5*\26\2\u00b6\u00ba\5,\27\2\u00b7\u00ba\5<\37\2\u00b8"+
"\u00ba\5\60\31\2\u00b9\u00b3\3\2\2\2\u00b9\u00b4\3\2\2\2\u00b9\u00b5\3"+
"\2\2\2\u00b9\u00b6\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00b8\3\2\2\2\u00ba"+
"\27\3\2\2\2\u00bb\u00c0\5\36\20\2\u00bc\u00c0\5\34\17\2\u00bd\u00c0\5"+
"\32\16\2\u00be\u00c0\5\16\b\2\u00bf\u00bb\3\2\2\2\u00bf\u00bc\3\2\2\2"+
"\u00bf\u00bd\3\2\2\2\u00bf\u00be\3\2\2\2\u00c0\31\3\2\2\2\u00c1\u00cb"+
"\5(\25\2\u00c2\u00cb\5\"\22\2\u00c3\u00cb\5 \21\2\u00c4\u00cb\5H%\2\u00c5"+
"\u00cb\5J&\2\u00c6\u00cb\5N(\2\u00c7\u00cb\5R*\2\u00c8\u00cb\5V,\2\u00c9"+
"\u00cb\5Z.\2\u00ca\u00c1\3\2\2\2\u00ca\u00c2\3\2\2\2\u00ca\u00c3\3\2\2"+
"\2\u00ca\u00c4\3\2\2\2\u00ca\u00c5\3\2\2\2\u00ca\u00c6\3\2\2\2\u00ca\u00c7"+
"\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00c9\3\2\2\2\u00cb\33\3\2\2\2\u00cc"+
"\u00da\5\66\34\2\u00cd\u00da\5.\30\2\u00ce\u00da\5:\36\2\u00cf\u00da\5"+
"8\35\2\u00d0\u00da\5\64\33\2\u00d1\u00da\5<\37\2\u00d2\u00da\5\60\31\2"+
"\u00d3\u00da\5\62\32\2\u00d4\u00da\5F$\2\u00d5\u00da\5L\'\2\u00d6\u00da"+
"\5P)\2\u00d7\u00da\5T+\2\u00d8\u00da\5X-\2\u00d9\u00cc\3\2\2\2\u00d9\u00cd"+
"\3\2\2\2\u00d9\u00ce\3\2\2\2\u00d9\u00cf\3\2\2\2\u00d9\u00d0\3\2\2\2\u00d9"+
"\u00d1\3\2\2\2\u00d9\u00d2\3\2\2\2\u00d9\u00d3\3\2\2\2\u00d9\u00d4\3\2"+
"\2\2\u00d9\u00d5\3\2\2\2\u00d9\u00d6\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9"+
"\u00d8\3\2\2\2\u00da\35\3\2\2\2\u00db\u00e0\5> \2\u00dc\u00e0\5@!\2\u00dd"+
"\u00e0\5B\"\2\u00de\u00e0\5D#\2\u00df\u00db\3\2\2\2\u00df\u00dc\3\2\2"+
"\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2\2\u00e0\37\3\2\2\2\u00e1\u00e2"+
"\7\35\2\2\u00e2!\3\2\2\2\u00e3\u00e4\7(\2\2\u00e4\u00e5\7\35\2\2\u00e5"+
"#\3\2\2\2\u00e6\u00e7\7!\2\2\u00e7%\3\2\2\2\u00e8\u00e9\7&\2\2\u00e9\'"+
"\3\2\2\2\u00ea\u00ec\7(\2\2\u00eb\u00ed\5j\66\2\u00ec\u00eb\3\2\2\2\u00ed"+
"\u00ee\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef)\3\2\2\2"+
"\u00f0\u00f1\7\34\2\2\u00f1\u00f2\7$\2\2\u00f2+\3\2\2\2\u00f3\u00f4\7"+
"\34\2\2\u00f4\u00f5\7\36\2\2\u00f5-\3\2\2\2\u00f6\u00f7\7\33\2\2\u00f7"+
"/\3\2\2\2\u00f8\u00f9\7\36\2\2\u00f9\61\3\2\2\2\u00fa\u00fb\7 \2\2\u00fb"+
"\63\3\2\2\2\u00fc\u00fd\7\"\2\2\u00fd\65\3\2\2\2\u00fe\u00ff\7$\2\2\u00ff"+
"\67\3\2\2\2\u0100\u0101\7%\2\2\u0101\u0102\7\36\2\2\u01029\3\2\2\2\u0103"+
"\u0105\7%\2\2\u0104\u0106\5\\/\2\u0105\u0104\3\2\2\2\u0106\u0107\3\2\2"+
"\2\u0107\u0105\3\2\2\2\u0107\u0108\3\2\2\2\u0108;\3\2\2\2\u0109\u010a"+
"\7\'\2\2\u010a=\3\2\2\2\u010b\u010c\7%\2\2\u010c\u010d\7\31\2\2\u010d"+
"\u010e\7<\2\2\u010e?\3\2\2\2\u010f\u0110\7%\2\2\u0110\u0111\7#\2\2\u0111"+
"\u0112\7<\2\2\u0112A\3\2\2\2\u0113\u0114\7(\2\2\u0114\u0115\7\31\2\2\u0115"+
"\u0116\7<\2\2\u0116C\3\2\2\2\u0117\u0118\7(\2\2\u0118\u0119\7#\2\2\u0119"+
"\u011a\7<\2\2\u011aE\3\2\2\2\u011b\u011c\7%\2\2\u011c\u011d\7)\2\2\u011d"+
"\u011f\5l\67\2\u011e\u0120\5\\/\2\u011f\u011e\3\2\2\2\u0120\u0121\3\2"+
"\2\2\u0121\u011f\3\2\2\2\u0121\u0122\3\2\2\2\u0122G\3\2\2\2\u0123\u0124"+
"\7(\2\2\u0124\u0125\7)\2\2\u0125\u0127\5l\67\2\u0126\u0128\5j\66\2\u0127"+
"\u0126\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u0127\3\2\2\2\u0129\u012a\3\2"+
"\2\2\u012aI\3\2\2\2\u012b\u012c\7(\2\2\u012c\u012d\7)\2\2\u012d\u012e"+
"\7*\2\2\u012eK\3\2\2\2\u012f\u0130\7%\2\2\u0130\u0131\7+\2\2\u0131\u0132"+
"\5\\/\2\u0132M\3\2\2\2\u0133\u0134\7(\2\2\u0134\u0135\7+\2\2\u0135\u0136"+
"\5j\66\2\u0136O\3\2\2\2\u0137\u0138\7%\2\2\u0138\u0139\7,\2\2\u0139\u013b"+
"\5l\67\2\u013a\u013c\5\\/\2\u013b\u013a\3\2\2\2\u013c\u013d\3\2\2\2\u013d"+
"\u013b\3\2\2\2\u013d\u013e\3\2\2\2\u013eQ\3\2\2\2\u013f\u0140\7(\2\2\u0140"+
"\u0141\7,\2\2\u0141\u0143\5l\67\2\u0142\u0144\5j\66\2\u0143\u0142\3\2"+
"\2\2\u0144\u0145\3\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146"+
"S\3\2\2\2\u0147\u0148\7%\2\2\u0148\u0149\7-\2\2\u0149\u014a\5\\/\2\u014a"+
"U\3\2\2\2\u014b\u014c\7(\2\2\u014c\u014d\7-\2\2\u014d\u014e\5j\66\2\u014e"+
"W\3\2\2\2\u014f\u0150\7%\2\2\u0150\u0151\7.\2\2\u0151\u0152\5\\/\2\u0152"+
"\u0153\5\\/\2\u0153Y\3\2\2\2\u0154\u0155\7(\2\2\u0155\u0156\7.\2\2\u0156"+
"\u0157\5j\66\2\u0157\u0158\5j\66\2\u0158[\3\2\2\2\u0159\u0160\5^\60\2"+
"\u015a\u0160\5`\61\2\u015b\u0160\5b\62\2\u015c\u0160\5d\63\2\u015d\u0160"+
"\5f\64\2\u015e\u0160\5h\65\2\u015f\u0159\3\2\2\2\u015f\u015a\3\2\2\2\u015f"+
"\u015b\3\2\2\2\u015f\u015c\3\2\2\2\u015f\u015d\3\2\2\2\u015f\u015e\3\2"+
"\2\2\u0160]\3\2\2\2\u0161\u0162\7;\2\2\u0162_\3\2\2\2\u0163\u016a\7\65"+
"\2\2\u0164\u016a\7\66\2\2\u0165\u016a\7\67\2\2\u0166\u0167\t\2\2\2\u0167"+
"\u016a\7\16\2\2\u0168\u016a\t\2\2\2\u0169\u0163\3\2\2\2\u0169\u0164\3"+
"\2\2\2\u0169\u0165\3\2\2\2\u0169\u0166\3\2\2\2\u0169\u0168\3\2\2\2\u016a"+
"a\3\2\2\2\u016b\u016c\7\64\2\2\u016cc\3\2\2\2\u016d\u016e\7\63\2\2\u016e"+
"e\3\2\2\2\u016f\u0170\7\13\2\2\u0170\u0171\7:\2\2\u0171\u0189\7\4\2\2"+
"\u0172\u0173\7\3\2\2\u0173\u0174\7:\2\2\u0174\u0175\7\4\2\2\u0175\u0176"+
"\7\62\2\2\u0176\u0189\7\6\2\2\u0177\u0178\7\t\2\2\u0178\u0179\7\62\2\2"+
"\u0179\u017a\7\n\2\2\u017a\u017b\7:\2\2\u017b\u0189\7\5\2\2\u017c\u017d"+
"\7\f\2\2\u017d\u017e\7\62\2\2\u017e\u0189\7\6\2\2\u017f\u0180\7\b\2\2"+
"\u0180\u0181\7\62\2\2\u0181\u0189\7\6\2\2\u0182\u0183\7\r\2\2\u0183\u0184"+
"\7\62\2\2\u0184\u0189\7\6\2\2\u0185\u0186\7\7\2\2\u0186\u0187\7\62\2\2"+
"\u0187\u0189\7\6\2\2\u0188\u016f\3\2\2\2\u0188\u0172\3\2\2\2\u0188\u0177"+
"\3\2\2\2\u0188\u017c\3\2\2\2\u0188\u017f\3\2\2\2\u0188\u0182\3\2\2\2\u0188"+
"\u0185\3\2\2\2\u0189g\3\2\2\2\u018a\u018b\7\13\2\2\u018b\u018c\7\63\2"+
"\2\u018c\u0193\7\4\2\2\u018d\u018e\7\3\2\2\u018e\u018f\7\63\2\2\u018f"+
"\u0190\7\4\2\2\u0190\u0191\7\62\2\2\u0191\u0193\7\6\2\2\u0192\u018a\3"+
"\2\2\2\u0192\u018d\3\2\2\2\u0193i\3\2\2\2\u0194\u0198\5l\67\2\u0195\u0198"+
"\5n8\2\u0196\u0198\5p9\2\u0197\u0194\3\2\2\2\u0197\u0195\3\2\2\2\u0197"+
"\u0196\3\2\2\2\u0198k\3\2\2\2\u0199\u019a\7;\2\2\u019am\3\2\2\2\u019b"+
"\u019c\7\65\2\2\u019co\3\2\2\2\u019d\u019e\7\63\2\2\u019eq\3\2\2\2\34"+
"u}\u0083\u0088\u008d\u0092\u0099\u009f\u00a3\u00b1\u00b9\u00bf\u00ca\u00d9"+
"\u00df\u00ee\u0107\u0121\u0129\u013d\u0145\u015f\u0169\u0188\u0192\u0197";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}