org.kaazing.robot.lang.regex.RegexParser Maven / Gradle / Ivy
// Generated from org/kaazing/robot/lang/regex/Regex.g4 by ANTLR 4.2.2
package org.kaazing.robot.lang.regex;
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 RegexParser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__2=1, T__1=2, T__0=3, ForwardSlash=4, LeftParen=5, RightParen=6, PatternNonGroup=7,
PatternNonCapturing=8, PatternCapturing=9, PatternQuantifiers=10, WS=11;
public static final String[] tokenNames = {
"", "'^'", "'|'", "'$'", "'/'", "'('", "')'", "PatternNonGroup",
"PatternNonCapturing", "PatternCapturing", "PatternQuantifiers", "WS"
};
public static final int
RULE_literal = 0, RULE_pattern = 1, RULE_expression = 2, RULE_sequence = 3,
RULE_group = 4, RULE_group0 = 5, RULE_groupN = 6;
public static final String[] ruleNames = {
"literal", "pattern", "expression", "sequence", "group", "group0", "groupN"
};
@Override
public String getGrammarFileName() { return "Regex.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 RegexParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class LiteralContext extends ParserRuleContext {
public PatternContext regex;
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public TerminalNode ForwardSlash(int i) {
return getToken(RegexParser.ForwardSlash, i);
}
public List ForwardSlash() { return getTokens(RegexParser.ForwardSlash); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 0, RULE_literal);
try {
enterOuterAlt(_localctx, 1);
{
setState(14); match(ForwardSlash);
setState(15); ((LiteralContext)_localctx).regex = pattern();
setState(16); match(ForwardSlash);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitPattern(this);
else return visitor.visitChildren(this);
}
}
public final PatternContext pattern() throws RecognitionException {
PatternContext _localctx = new PatternContext(_ctx, getState());
enterRule(_localctx, 2, RULE_pattern);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(19);
_la = _input.LA(1);
if (_la==1) {
{
setState(18); match(1);
}
}
setState(21); expression();
setState(23);
_la = _input.LA(1);
if (_la==3) {
{
setState(22); match(3);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public SequenceContext sequence(int i) {
return getRuleContext(SequenceContext.class,i);
}
public List sequence() {
return getRuleContexts(SequenceContext.class);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(25); sequence();
setState(30);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==2) {
{
{
setState(26); match(2);
setState(27); sequence();
}
}
setState(32);
_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 SequenceContext extends ParserRuleContext {
public GroupContext group(int i) {
return getRuleContext(GroupContext.class,i);
}
public List group() {
return getRuleContexts(GroupContext.class);
}
public SequenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sequence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterSequence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitSequence(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitSequence(this);
else return visitor.visitChildren(this);
}
}
public final SequenceContext sequence() throws RecognitionException {
SequenceContext _localctx = new SequenceContext(_ctx, getState());
enterRule(_localctx, 6, RULE_sequence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(34);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(33); group();
}
}
setState(36);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LeftParen || _la==PatternNonGroup );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupContext extends ParserRuleContext {
public TerminalNode PatternNonGroup() { return getToken(RegexParser.PatternNonGroup, 0); }
public Group0Context group0() {
return getRuleContext(Group0Context.class,0);
}
public GroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_group; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitGroup(this);
else return visitor.visitChildren(this);
}
}
public final GroupContext group() throws RecognitionException {
GroupContext _localctx = new GroupContext(_ctx, getState());
enterRule(_localctx, 8, RULE_group);
try {
setState(40);
switch (_input.LA(1)) {
case PatternNonGroup:
enterOuterAlt(_localctx, 1);
{
setState(38); match(PatternNonGroup);
}
break;
case LeftParen:
enterOuterAlt(_localctx, 2);
{
setState(39); group0();
}
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 Group0Context extends ParserRuleContext {
public GroupNContext groupN() {
return getRuleContext(GroupNContext.class,0);
}
public TerminalNode LeftParen() { return getToken(RegexParser.LeftParen, 0); }
public TerminalNode PatternQuantifiers() { return getToken(RegexParser.PatternQuantifiers, 0); }
public TerminalNode RightParen() { return getToken(RegexParser.RightParen, 0); }
public Group0Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_group0; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterGroup0(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitGroup0(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitGroup0(this);
else return visitor.visitChildren(this);
}
}
public final Group0Context group0() throws RecognitionException {
Group0Context _localctx = new Group0Context(_ctx, getState());
enterRule(_localctx, 10, RULE_group0);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(42); match(LeftParen);
setState(43); groupN();
setState(44); match(RightParen);
setState(46);
_la = _input.LA(1);
if (_la==PatternQuantifiers) {
{
setState(45); match(PatternQuantifiers);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupNContext extends ParserRuleContext {
public Token capture;
public TerminalNode PatternNonCapturing() { return getToken(RegexParser.PatternNonCapturing, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode PatternCapturing() { return getToken(RegexParser.PatternCapturing, 0); }
public GroupNContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupN; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).enterGroupN(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RegexListener ) ((RegexListener)listener).exitGroupN(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RegexVisitor ) return ((RegexVisitor)visitor).visitGroupN(this);
else return visitor.visitChildren(this);
}
}
public final GroupNContext groupN() throws RecognitionException {
GroupNContext _localctx = new GroupNContext(_ctx, getState());
enterRule(_localctx, 12, RULE_groupN);
try {
setState(53);
switch (_input.LA(1)) {
case LeftParen:
case PatternNonGroup:
enterOuterAlt(_localctx, 1);
{
setState(48); expression();
}
break;
case PatternNonCapturing:
enterOuterAlt(_localctx, 2);
{
setState(49); match(PatternNonCapturing);
setState(50); expression();
}
break;
case PatternCapturing:
enterOuterAlt(_localctx, 3);
{
setState(51); ((GroupNContext)_localctx).capture = match(PatternCapturing);
setState(52); expression();
}
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 final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\r:\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\3\2\3\2\3\2\3\2\3\3\5\3\26"+
"\n\3\3\3\3\3\5\3\32\n\3\3\4\3\4\3\4\7\4\37\n\4\f\4\16\4\"\13\4\3\5\6\5"+
"%\n\5\r\5\16\5&\3\6\3\6\5\6+\n\6\3\7\3\7\3\7\3\7\5\7\61\n\7\3\b\3\b\3"+
"\b\3\b\3\b\5\b8\n\b\3\b\2\2\t\2\4\6\b\n\f\16\2\2:\2\20\3\2\2\2\4\25\3"+
"\2\2\2\6\33\3\2\2\2\b$\3\2\2\2\n*\3\2\2\2\f,\3\2\2\2\16\67\3\2\2\2\20"+
"\21\7\6\2\2\21\22\5\4\3\2\22\23\7\6\2\2\23\3\3\2\2\2\24\26\7\3\2\2\25"+
"\24\3\2\2\2\25\26\3\2\2\2\26\27\3\2\2\2\27\31\5\6\4\2\30\32\7\5\2\2\31"+
"\30\3\2\2\2\31\32\3\2\2\2\32\5\3\2\2\2\33 \5\b\5\2\34\35\7\4\2\2\35\37"+
"\5\b\5\2\36\34\3\2\2\2\37\"\3\2\2\2 \36\3\2\2\2 !\3\2\2\2!\7\3\2\2\2\""+
" \3\2\2\2#%\5\n\6\2$#\3\2\2\2%&\3\2\2\2&$\3\2\2\2&\'\3\2\2\2\'\t\3\2\2"+
"\2(+\7\t\2\2)+\5\f\7\2*(\3\2\2\2*)\3\2\2\2+\13\3\2\2\2,-\7\7\2\2-.\5\16"+
"\b\2.\60\7\b\2\2/\61\7\f\2\2\60/\3\2\2\2\60\61\3\2\2\2\61\r\3\2\2\2\62"+
"8\5\6\4\2\63\64\7\n\2\2\648\5\6\4\2\65\66\7\13\2\2\668\5\6\4\2\67\62\3"+
"\2\2\2\67\63\3\2\2\2\67\65\3\2\2\28\17\3\2\2\2\t\25\31 &*\60\67";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy