1 package it.unical.mat.parsers.asp.clingo;
3 import org.antlr.v4.runtime.atn.*;
4 import org.antlr.v4.runtime.dfa.DFA;
5 import org.antlr.v4.runtime.*;
6 import org.antlr.v4.runtime.misc.*;
7 import org.antlr.v4.runtime.tree.*;
9 import java.util.Iterator;
10 import java.util.ArrayList;
12 @SuppressWarnings({
"all",
"warnings",
"unchecked",
"unused",
"cast"})
14 static { RuntimeMetaData.checkVersion(
"4.7", RuntimeMetaData.VERSION); }
16 protected static final DFA[] _decisionToDFA;
17 protected static final PredictionContextCache _sharedContextCache =
18 new PredictionContextCache();
19 public static final int
20 START=1, ANY=2, COMMA=3, INTEGER_CONSTANT=4, NEW_LINE=5, IDENTIFIER=6,
21 STRING_CONSTANT=7, TERMS_BEGIN=8, TERMS_END=9, WHITE_SPACE=10;
22 public static final int
23 RULE_answer_set = 0, RULE_model = 1, RULE_output = 2, RULE_predicate_atom = 3,
25 public static final String[] ruleNames = {
26 "answer_set",
"model",
"output",
"predicate_atom",
"term"
29 private static final String[] _LITERAL_NAMES = {
30 null,
null,
null,
"','",
null,
null,
null,
null,
"'('",
"')'"
32 private static final String[] _SYMBOLIC_NAMES = {
33 null,
"START",
"ANY",
"COMMA",
"INTEGER_CONSTANT",
"NEW_LINE",
"IDENTIFIER",
34 "STRING_CONSTANT",
"TERMS_BEGIN",
"TERMS_END",
"WHITE_SPACE"
36 public static final Vocabulary VOCABULARY =
new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
44 tokenNames =
new String[_SYMBOLIC_NAMES.length];
45 for (
int i = 0; i < tokenNames.length; i++) {
46 tokenNames[i] = VOCABULARY.getLiteralName(i);
47 if (tokenNames[i] ==
null) {
48 tokenNames[i] = VOCABULARY.getSymbolicName(i);
51 if (tokenNames[i] ==
null) {
52 tokenNames[i] =
"<INVALID>";
59 public String[] getTokenNames() {
65 public Vocabulary getVocabulary() {
70 public String getGrammarFileName() {
return "ClingoParser.g4"; }
73 public String[] getRuleNames() {
return ruleNames; }
76 public String getSerializedATN() {
return _serializedATN; }
79 public ATN getATN() {
return _ATN; }
81 public ClingoParser(TokenStream input) {
83 _interp =
new ParserATNSimulator(
this,_ATN,_decisionToDFA,_sharedContextCache);
85 public static class Answer_setContext
extends ParserRuleContext {
86 public TerminalNode START() {
return getToken(ClingoParser.START, 0); }
87 public ModelContext model() {
88 return getRuleContext(ModelContext.class,0);
90 public Answer_setContext(ParserRuleContext parent,
int invokingState) {
91 super(parent, invokingState);
93 @Override
public int getRuleIndex() {
return RULE_answer_set; }
95 public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
96 if ( visitor instanceof ClingoParserVisitor )
return ((ClingoParserVisitor<? extends T>)visitor).visitAnswer_set(
this);
97 else return visitor.visitChildren(
this);
101 public final Answer_setContext answer_set() throws RecognitionException {
102 Answer_setContext _localctx =
new Answer_setContext(_ctx, getState());
103 enterRule(_localctx, 0, RULE_answer_set);
105 enterOuterAlt(_localctx, 1);
113 catch (RecognitionException re) {
114 _localctx.exception = re;
115 _errHandler.reportError(
this, re);
116 _errHandler.recover(
this, re);
124 public static class ModelContext
extends ParserRuleContext {
125 public TerminalNode NEW_LINE() {
return getToken(ClingoParser.NEW_LINE, 0); }
126 public List<Predicate_atomContext> predicate_atom() {
127 return getRuleContexts(Predicate_atomContext.class);
129 public Predicate_atomContext predicate_atom(
int i) {
130 return getRuleContext(Predicate_atomContext.class,i);
132 public ModelContext(ParserRuleContext parent,
int invokingState) {
133 super(parent, invokingState);
135 @Override
public int getRuleIndex() {
return RULE_model; }
137 public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
138 if ( visitor instanceof ClingoParserVisitor )
return ((ClingoParserVisitor<? extends T>)visitor).visitModel(
this);
139 else return visitor.visitChildren(
this);
143 public final ModelContext model() throws RecognitionException {
144 ModelContext _localctx =
new ModelContext(_ctx, getState());
145 enterRule(_localctx, 2, RULE_model);
148 enterOuterAlt(_localctx, 1);
151 _errHandler.sync(
this);
153 while (_la==IDENTIFIER) {
161 _errHandler.sync(
this);
168 catch (RecognitionException re) {
169 _localctx.exception = re;
170 _errHandler.reportError(
this, re);
171 _errHandler.recover(
this, re);
179 public static class OutputContext
extends ParserRuleContext {
180 public List<Answer_setContext> answer_set() {
181 return getRuleContexts(Answer_setContext.class);
183 public Answer_setContext answer_set(
int i) {
184 return getRuleContext(Answer_setContext.class,i);
186 public OutputContext(ParserRuleContext parent,
int invokingState) {
187 super(parent, invokingState);
189 @Override
public int getRuleIndex() {
return RULE_output; }
191 public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
192 if ( visitor instanceof ClingoParserVisitor )
return ((ClingoParserVisitor<? extends T>)visitor).visitOutput(
this);
193 else return visitor.visitChildren(
this);
197 public final OutputContext output() throws RecognitionException {
198 OutputContext _localctx =
new OutputContext(_ctx, getState());
199 enterRule(_localctx, 4, RULE_output);
202 enterOuterAlt(_localctx, 1);
205 _errHandler.sync(
this);
215 _errHandler.sync(
this);
220 catch (RecognitionException re) {
221 _localctx.exception = re;
222 _errHandler.reportError(
this, re);
223 _errHandler.recover(
this, re);
231 public static class Predicate_atomContext
extends ParserRuleContext {
232 public TerminalNode IDENTIFIER() {
return getToken(ClingoParser.IDENTIFIER, 0); }
233 public TerminalNode TERMS_BEGIN() {
return getToken(ClingoParser.TERMS_BEGIN, 0); }
234 public List<TermContext> term() {
235 return getRuleContexts(TermContext.class);
237 public TermContext term(
int i) {
238 return getRuleContext(TermContext.class,i);
240 public TerminalNode TERMS_END() {
return getToken(ClingoParser.TERMS_END, 0); }
241 public List<TerminalNode> COMMA() {
return getTokens(ClingoParser.COMMA); }
242 public TerminalNode COMMA(
int i) {
243 return getToken(ClingoParser.COMMA, i);
245 public Predicate_atomContext(ParserRuleContext parent,
int invokingState) {
246 super(parent, invokingState);
248 @Override
public int getRuleIndex() {
return RULE_predicate_atom; }
250 public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
251 if ( visitor instanceof ClingoParserVisitor )
return ((ClingoParserVisitor<? extends T>)visitor).visitPredicate_atom(
this);
252 else return visitor.visitChildren(
this);
256 public final Predicate_atomContext predicate_atom() throws RecognitionException {
257 Predicate_atomContext _localctx =
new Predicate_atomContext(_ctx, getState());
258 enterRule(_localctx, 6, RULE_predicate_atom);
261 enterOuterAlt(_localctx, 1);
266 _errHandler.sync(
this);
268 if (_la==TERMS_BEGIN) {
275 _errHandler.sync(
this);
287 _errHandler.sync(
this);
297 catch (RecognitionException re) {
298 _localctx.exception = re;
299 _errHandler.reportError(
this, re);
300 _errHandler.recover(
this, re);
308 public static class TermContext
extends ParserRuleContext {
309 public TerminalNode IDENTIFIER() {
return getToken(ClingoParser.IDENTIFIER, 0); }
310 public TerminalNode INTEGER_CONSTANT() {
return getToken(ClingoParser.INTEGER_CONSTANT, 0); }
311 public Predicate_atomContext predicate_atom() {
312 return getRuleContext(Predicate_atomContext.class,0);
314 public TerminalNode STRING_CONSTANT() {
return getToken(ClingoParser.STRING_CONSTANT, 0); }
315 public TermContext(ParserRuleContext parent,
int invokingState) {
316 super(parent, invokingState);
318 @Override
public int getRuleIndex() {
return RULE_term; }
320 public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
321 if ( visitor instanceof ClingoParserVisitor )
return ((ClingoParserVisitor<? extends T>)visitor).visitTerm(
this);
322 else return visitor.visitChildren(
this);
326 public final TermContext term() throws RecognitionException {
327 TermContext _localctx =
new TermContext(_ctx, getState());
328 enterRule(_localctx, 8, RULE_term);
331 _errHandler.sync(
this);
332 switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
334 enterOuterAlt(_localctx, 1);
341 enterOuterAlt(_localctx, 2);
344 match(INTEGER_CONSTANT);
348 enterOuterAlt(_localctx, 3);
355 enterOuterAlt(_localctx, 4);
358 match(STRING_CONSTANT);
363 catch (RecognitionException re) {
364 _localctx.exception = re;
365 _errHandler.reportError(
this, re);
366 _errHandler.recover(
this, re);
374 public static final String _serializedATN =
375 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\f\62\4\2\t\2\4\3"+
376 "\t\3\4\4\t\4\4\5\t\5\4\6\t\6\3\2\3\2\3\2\3\3\7\3\21\n\3\f\3\16\3\24\13"+
377 "\3\3\3\3\3\3\4\7\4\31\n\4\f\4\16\4\34\13\4\3\5\3\5\3\5\3\5\3\5\7\5#\n"+
378 "\5\f\5\16\5&\13\5\3\5\3\5\5\5*\n\5\3\6\3\6\3\6\3\6\5\6\60\n\6\3\6\2\2"+
379 "\7\2\4\6\b\n\2\2\2\63\2\f\3\2\2\2\4\22\3\2\2\2\6\32\3\2\2\2\b\35\3\2\2"+
380 "\2\n/\3\2\2\2\f\r\7\3\2\2\r\16\5\4\3\2\16\3\3\2\2\2\17\21\5\b\5\2\20\17"+
381 "\3\2\2\2\21\24\3\2\2\2\22\20\3\2\2\2\22\23\3\2\2\2\23\25\3\2\2\2\24\22"+
382 "\3\2\2\2\25\26\7\7\2\2\26\5\3\2\2\2\27\31\5\2\2\2\30\27\3\2\2\2\31\34"+
383 "\3\2\2\2\32\30\3\2\2\2\32\33\3\2\2\2\33\7\3\2\2\2\34\32\3\2\2\2\35)\7"+
384 "\b\2\2\36\37\7\n\2\2\37$\5\n\6\2 !\7\5\2\2!#\5\n\6\2\" \3\2\2\2#&\3\2"+
385 "\2\2$\"\3\2\2\2$%\3\2\2\2%\'\3\2\2\2&$\3\2\2\2\'(\7\13\2\2(*\3\2\2\2)"+
386 "\36\3\2\2\2)*\3\2\2\2*\t\3\2\2\2+\60\7\b\2\2,\60\7\6\2\2-\60\5\b\5\2."+
387 "\60\7\t\2\2/+\3\2\2\2/,\3\2\2\2/-\3\2\2\2/.\3\2\2\2\60\13\3\2\2\2\7\22"+
389 public static final ATN _ATN =
390 new ATNDeserializer().deserialize(_serializedATN.toCharArray());
392 _decisionToDFA =
new DFA[_ATN.getNumberOfDecisions()];
393 for (
int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
394 _decisionToDFA[i] =
new DFA(_ATN.getDecisionState(i), i);