net.fchauvel.trio.builder.TrioParser Maven / Gradle / Ivy
The newest version!
// Generated from net\fchauvel\trio\builder\Trio.g4 by ANTLR 4.3
package net.fchauvel.trio.builder;
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 TrioParser extends Parser {
static { RuntimeMetaData.checkVersion("4.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__13=1, T__12=2, T__11=3, T__10=4, T__9=5, T__8=6, T__7=7, T__6=8, T__5=9,
T__4=10, T__3=11, T__2=12, T__1=13, T__0=14, DIGIT=15, REAL=16, INTEGER=17,
LETTER=18, ID=19, STRING=20, WS=21, LINE_COMMENT=22;
public static final String[] tokenNames = {
"", "'tags'", "'requires'", "':'", "'['", "'on'", "']'", "'or'",
"'system'", "'('", "'components'", "')'", "'and'", "','", "'-'", "DIGIT",
"REAL", "INTEGER", "LETTER", "ID", "STRING", "WS", "LINE_COMMENT"
};
public static final int
RULE_system = 0, RULE_description = 1, RULE_component = 2, RULE_mttf = 3,
RULE_requirements = 4, RULE_expression = 5, RULE_tags = 6, RULE_tag = 7;
public static final String[] ruleNames = {
"system", "description", "component", "mttf", "requirements", "expression",
"tags", "tag"
};
@Override
public String getGrammarFileName() { return "Trio.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 TrioParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class SystemContext extends ParserRuleContext {
public DescriptionContext description() {
return getRuleContext(DescriptionContext.class,0);
}
public TagsContext tags() {
return getRuleContext(TagsContext.class,0);
}
public ComponentContext component(int i) {
return getRuleContext(ComponentContext.class,i);
}
public List component() {
return getRuleContexts(ComponentContext.class);
}
public SystemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_system; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterSystem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitSystem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitSystem(this);
else return visitor.visitChildren(this);
}
}
public final SystemContext system() throws RecognitionException {
SystemContext _localctx = new SystemContext(_ctx, getState());
enterRule(_localctx, 0, RULE_system);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(17);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(16); description();
}
}
setState(19); match(T__4);
setState(20); match(T__11);
setState(22);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(21); component();
}
}
setState(24);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__0 || _la==ID );
setState(27);
_la = _input.LA(1);
if (_la==T__13) {
{
setState(26); tags();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DescriptionContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(TrioParser.STRING, 0); }
public DescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_description; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitDescription(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitDescription(this);
else return visitor.visitChildren(this);
}
}
public final DescriptionContext description() throws RecognitionException {
DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_description);
try {
enterOuterAlt(_localctx, 1);
{
setState(29); match(T__6);
setState(30); match(T__11);
setState(31); match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ComponentContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(TrioParser.ID, 0); }
public RequirementsContext requirements() {
return getRuleContext(RequirementsContext.class,0);
}
public MttfContext mttf() {
return getRuleContext(MttfContext.class,0);
}
public ComponentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_component; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterComponent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitComponent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitComponent(this);
else return visitor.visitChildren(this);
}
}
public final ComponentContext component() throws RecognitionException {
ComponentContext _localctx = new ComponentContext(_ctx, getState());
enterRule(_localctx, 4, RULE_component);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(34);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(33); match(T__0);
}
}
setState(36); match(ID);
setState(38);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(37); mttf();
}
}
setState(41);
_la = _input.LA(1);
if (_la==T__12) {
{
setState(40); requirements();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MttfContext extends ParserRuleContext {
public TerminalNode REAL() { return getToken(TrioParser.REAL, 0); }
public MttfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mttf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterMttf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitMttf(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitMttf(this);
else return visitor.visitChildren(this);
}
}
public final MttfContext mttf() throws RecognitionException {
MttfContext _localctx = new MttfContext(_ctx, getState());
enterRule(_localctx, 6, RULE_mttf);
try {
enterOuterAlt(_localctx, 1);
{
setState(43); match(T__10);
setState(44); match(REAL);
setState(45); match(T__8);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RequirementsContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public RequirementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_requirements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterRequirements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitRequirements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitRequirements(this);
else return visitor.visitChildren(this);
}
}
public final RequirementsContext requirements() throws RecognitionException {
RequirementsContext _localctx = new RequirementsContext(_ctx, getState());
enterRule(_localctx, 8, RULE_requirements);
try {
enterOuterAlt(_localctx, 1);
{
setState(47); match(T__12);
setState(48); expression(0);
}
}
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 ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class DisjunctionContext extends ExpressionContext {
public ExpressionContext left;
public ExpressionContext right;
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public DisjunctionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterDisjunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitDisjunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitDisjunction(this);
else return visitor.visitChildren(this);
}
}
public static class BracketsContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BracketsContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterBrackets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitBrackets(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitBrackets(this);
else return visitor.visitChildren(this);
}
}
public static class ReferenceContext extends ExpressionContext {
public TerminalNode ID() { return getToken(TrioParser.ID, 0); }
public ReferenceContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitReference(this);
else return visitor.visitChildren(this);
}
}
public static class ConjunctionContext extends ExpressionContext {
public ExpressionContext left;
public ExpressionContext right;
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ConjunctionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterConjunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitConjunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitConjunction(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 10;
enterRecursionRule(_localctx, 10, RULE_expression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(56);
switch (_input.LA(1)) {
case ID:
{
_localctx = new ReferenceContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(51); match(ID);
}
break;
case T__5:
{
_localctx = new BracketsContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(52); match(T__5);
setState(53); expression(0);
setState(54); match(T__3);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(66);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(64);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
_localctx = new ConjunctionContext(new ExpressionContext(_parentctx, _parentState));
((ConjunctionContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(58);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(59); match(T__2);
setState(60); ((ConjunctionContext)_localctx).right = expression(4);
}
break;
case 2:
{
_localctx = new DisjunctionContext(new ExpressionContext(_parentctx, _parentState));
((DisjunctionContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(61);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(62); match(T__7);
setState(63); ((DisjunctionContext)_localctx).right = expression(3);
}
break;
}
}
}
setState(68);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TagsContext extends ParserRuleContext {
public List tag() {
return getRuleContexts(TagContext.class);
}
public TagContext tag(int i) {
return getRuleContext(TagContext.class,i);
}
public TagsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tags; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterTags(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitTags(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitTags(this);
else return visitor.visitChildren(this);
}
}
public final TagsContext tags() throws RecognitionException {
TagsContext _localctx = new TagsContext(_ctx, getState());
enterRule(_localctx, 12, RULE_tags);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(69); match(T__13);
setState(70); match(T__11);
setState(72);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(71); tag();
}
}
setState(74);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__0 || _la==STRING );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TagContext extends ParserRuleContext {
public List ID() { return getTokens(TrioParser.ID); }
public TerminalNode STRING() { return getToken(TrioParser.STRING, 0); }
public TerminalNode ID(int i) {
return getToken(TrioParser.ID, i);
}
public TagContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tag; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).enterTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TrioListener ) ((TrioListener)listener).exitTag(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TrioVisitor ) return ((TrioVisitor)visitor).visitTag(this);
else return visitor.visitChildren(this);
}
}
public final TagContext tag() throws RecognitionException {
TagContext _localctx = new TagContext(_ctx, getState());
enterRule(_localctx, 14, RULE_tag);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(77);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(76); match(T__0);
}
}
setState(79); match(STRING);
setState(80); match(T__9);
setState(81); match(ID);
setState(86);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(82); match(T__1);
setState(83); match(ID);
}
}
setState(88);
_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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 5: return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0: return precpred(_ctx, 3);
case 1: return precpred(_ctx, 2);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\30\\\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\3\2\5\2\24\n\2\3"+
"\2\3\2\3\2\6\2\31\n\2\r\2\16\2\32\3\2\5\2\36\n\2\3\3\3\3\3\3\3\3\3\4\5"+
"\4%\n\4\3\4\3\4\5\4)\n\4\3\4\5\4,\n\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\7"+
"\3\7\3\7\3\7\3\7\3\7\5\7;\n\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7C\n\7\f\7\16"+
"\7F\13\7\3\b\3\b\3\b\6\bK\n\b\r\b\16\bL\3\t\5\tP\n\t\3\t\3\t\3\t\3\t\3"+
"\t\7\tW\n\t\f\t\16\tZ\13\t\3\t\2\3\f\n\2\4\6\b\n\f\16\20\2\2_\2\23\3\2"+
"\2\2\4\37\3\2\2\2\6$\3\2\2\2\b-\3\2\2\2\n\61\3\2\2\2\f:\3\2\2\2\16G\3"+
"\2\2\2\20O\3\2\2\2\22\24\5\4\3\2\23\22\3\2\2\2\23\24\3\2\2\2\24\25\3\2"+
"\2\2\25\26\7\f\2\2\26\30\7\5\2\2\27\31\5\6\4\2\30\27\3\2\2\2\31\32\3\2"+
"\2\2\32\30\3\2\2\2\32\33\3\2\2\2\33\35\3\2\2\2\34\36\5\16\b\2\35\34\3"+
"\2\2\2\35\36\3\2\2\2\36\3\3\2\2\2\37 \7\n\2\2 !\7\5\2\2!\"\7\26\2\2\""+
"\5\3\2\2\2#%\7\20\2\2$#\3\2\2\2$%\3\2\2\2%&\3\2\2\2&(\7\25\2\2\')\5\b"+
"\5\2(\'\3\2\2\2()\3\2\2\2)+\3\2\2\2*,\5\n\6\2+*\3\2\2\2+,\3\2\2\2,\7\3"+
"\2\2\2-.\7\6\2\2./\7\22\2\2/\60\7\b\2\2\60\t\3\2\2\2\61\62\7\4\2\2\62"+
"\63\5\f\7\2\63\13\3\2\2\2\64\65\b\7\1\2\65;\7\25\2\2\66\67\7\13\2\2\67"+
"8\5\f\7\289\7\r\2\29;\3\2\2\2:\64\3\2\2\2:\66\3\2\2\2;D\3\2\2\2<=\f\5"+
"\2\2=>\7\16\2\2>C\5\f\7\6?@\f\4\2\2@A\7\t\2\2AC\5\f\7\5B<\3\2\2\2B?\3"+
"\2\2\2CF\3\2\2\2DB\3\2\2\2DE\3\2\2\2E\r\3\2\2\2FD\3\2\2\2GH\7\3\2\2HJ"+
"\7\5\2\2IK\5\20\t\2JI\3\2\2\2KL\3\2\2\2LJ\3\2\2\2LM\3\2\2\2M\17\3\2\2"+
"\2NP\7\20\2\2ON\3\2\2\2OP\3\2\2\2PQ\3\2\2\2QR\7\26\2\2RS\7\7\2\2SX\7\25"+
"\2\2TU\7\17\2\2UW\7\25\2\2VT\3\2\2\2WZ\3\2\2\2XV\3\2\2\2XY\3\2\2\2Y\21"+
"\3\2\2\2ZX\3\2\2\2\16\23\32\35$(+:BDLOX";
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