EmbASP-Java
ClingoParser.java
1 package it.unical.mat.parsers.asp.clingo;
2 
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.*;
8 import java.util.List;
9 import java.util.Iterator;
10 import java.util.ArrayList;
11 
12 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
13 public class ClingoParser extends Parser {
14  static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
15 
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,
24  RULE_term = 4;
25  public static final String[] ruleNames = {
26  "answer_set", "model", "output", "predicate_atom", "term"
27  };
28 
29  private static final String[] _LITERAL_NAMES = {
30  null, null, null, "','", null, null, null, null, "'('", "')'"
31  };
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"
35  };
36  public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
37 
41  @Deprecated
42  public static final String[] tokenNames;
43  static {
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);
49  }
50 
51  if (tokenNames[i] == null) {
52  tokenNames[i] = "<INVALID>";
53  }
54  }
55  }
56 
57  @Override
58  @Deprecated
59  public String[] getTokenNames() {
60  return tokenNames;
61  }
62 
63  @Override
64 
65  public Vocabulary getVocabulary() {
66  return VOCABULARY;
67  }
68 
69  @Override
70  public String getGrammarFileName() { return "ClingoParser.g4"; }
71 
72  @Override
73  public String[] getRuleNames() { return ruleNames; }
74 
75  @Override
76  public String getSerializedATN() { return _serializedATN; }
77 
78  @Override
79  public ATN getATN() { return _ATN; }
80 
81  public ClingoParser(TokenStream input) {
82  super(input);
83  _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
84  }
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);
89  }
90  public Answer_setContext(ParserRuleContext parent, int invokingState) {
91  super(parent, invokingState);
92  }
93  @Override public int getRuleIndex() { return RULE_answer_set; }
94  @Override
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);
98  }
99  }
100 
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);
104  try {
105  enterOuterAlt(_localctx, 1);
106  {
107  setState(10);
108  match(START);
109  setState(11);
110  model();
111  }
112  }
113  catch (RecognitionException re) {
114  _localctx.exception = re;
115  _errHandler.reportError(this, re);
116  _errHandler.recover(this, re);
117  }
118  finally {
119  exitRule();
120  }
121  return _localctx;
122  }
123 
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);
128  }
129  public Predicate_atomContext predicate_atom(int i) {
130  return getRuleContext(Predicate_atomContext.class,i);
131  }
132  public ModelContext(ParserRuleContext parent, int invokingState) {
133  super(parent, invokingState);
134  }
135  @Override public int getRuleIndex() { return RULE_model; }
136  @Override
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);
140  }
141  }
142 
143  public final ModelContext model() throws RecognitionException {
144  ModelContext _localctx = new ModelContext(_ctx, getState());
145  enterRule(_localctx, 2, RULE_model);
146  int _la;
147  try {
148  enterOuterAlt(_localctx, 1);
149  {
150  setState(16);
151  _errHandler.sync(this);
152  _la = _input.LA(1);
153  while (_la==IDENTIFIER) {
154  {
155  {
156  setState(13);
157  predicate_atom();
158  }
159  }
160  setState(18);
161  _errHandler.sync(this);
162  _la = _input.LA(1);
163  }
164  setState(19);
165  match(NEW_LINE);
166  }
167  }
168  catch (RecognitionException re) {
169  _localctx.exception = re;
170  _errHandler.reportError(this, re);
171  _errHandler.recover(this, re);
172  }
173  finally {
174  exitRule();
175  }
176  return _localctx;
177  }
178 
179  public static class OutputContext extends ParserRuleContext {
180  public List<Answer_setContext> answer_set() {
181  return getRuleContexts(Answer_setContext.class);
182  }
183  public Answer_setContext answer_set(int i) {
184  return getRuleContext(Answer_setContext.class,i);
185  }
186  public OutputContext(ParserRuleContext parent, int invokingState) {
187  super(parent, invokingState);
188  }
189  @Override public int getRuleIndex() { return RULE_output; }
190  @Override
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);
194  }
195  }
196 
197  public final OutputContext output() throws RecognitionException {
198  OutputContext _localctx = new OutputContext(_ctx, getState());
199  enterRule(_localctx, 4, RULE_output);
200  int _la;
201  try {
202  enterOuterAlt(_localctx, 1);
203  {
204  setState(24);
205  _errHandler.sync(this);
206  _la = _input.LA(1);
207  while (_la==START) {
208  {
209  {
210  setState(21);
211  answer_set();
212  }
213  }
214  setState(26);
215  _errHandler.sync(this);
216  _la = _input.LA(1);
217  }
218  }
219  }
220  catch (RecognitionException re) {
221  _localctx.exception = re;
222  _errHandler.reportError(this, re);
223  _errHandler.recover(this, re);
224  }
225  finally {
226  exitRule();
227  }
228  return _localctx;
229  }
230 
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);
236  }
237  public TermContext term(int i) {
238  return getRuleContext(TermContext.class,i);
239  }
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);
244  }
245  public Predicate_atomContext(ParserRuleContext parent, int invokingState) {
246  super(parent, invokingState);
247  }
248  @Override public int getRuleIndex() { return RULE_predicate_atom; }
249  @Override
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);
253  }
254  }
255 
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);
259  int _la;
260  try {
261  enterOuterAlt(_localctx, 1);
262  {
263  setState(27);
264  match(IDENTIFIER);
265  setState(39);
266  _errHandler.sync(this);
267  _la = _input.LA(1);
268  if (_la==TERMS_BEGIN) {
269  {
270  setState(28);
271  match(TERMS_BEGIN);
272  setState(29);
273  term();
274  setState(34);
275  _errHandler.sync(this);
276  _la = _input.LA(1);
277  while (_la==COMMA) {
278  {
279  {
280  setState(30);
281  match(COMMA);
282  setState(31);
283  term();
284  }
285  }
286  setState(36);
287  _errHandler.sync(this);
288  _la = _input.LA(1);
289  }
290  setState(37);
291  match(TERMS_END);
292  }
293  }
294 
295  }
296  }
297  catch (RecognitionException re) {
298  _localctx.exception = re;
299  _errHandler.reportError(this, re);
300  _errHandler.recover(this, re);
301  }
302  finally {
303  exitRule();
304  }
305  return _localctx;
306  }
307 
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);
313  }
314  public TerminalNode STRING_CONSTANT() { return getToken(ClingoParser.STRING_CONSTANT, 0); }
315  public TermContext(ParserRuleContext parent, int invokingState) {
316  super(parent, invokingState);
317  }
318  @Override public int getRuleIndex() { return RULE_term; }
319  @Override
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);
323  }
324  }
325 
326  public final TermContext term() throws RecognitionException {
327  TermContext _localctx = new TermContext(_ctx, getState());
328  enterRule(_localctx, 8, RULE_term);
329  try {
330  setState(45);
331  _errHandler.sync(this);
332  switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
333  case 1:
334  enterOuterAlt(_localctx, 1);
335  {
336  setState(41);
337  match(IDENTIFIER);
338  }
339  break;
340  case 2:
341  enterOuterAlt(_localctx, 2);
342  {
343  setState(42);
344  match(INTEGER_CONSTANT);
345  }
346  break;
347  case 3:
348  enterOuterAlt(_localctx, 3);
349  {
350  setState(43);
351  predicate_atom();
352  }
353  break;
354  case 4:
355  enterOuterAlt(_localctx, 4);
356  {
357  setState(44);
358  match(STRING_CONSTANT);
359  }
360  break;
361  }
362  }
363  catch (RecognitionException re) {
364  _localctx.exception = re;
365  _errHandler.reportError(this, re);
366  _errHandler.recover(this, re);
367  }
368  finally {
369  exitRule();
370  }
371  return _localctx;
372  }
373 
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"+
388  "\32$)/";
389  public static final ATN _ATN =
390  new ATNDeserializer().deserialize(_serializedATN.toCharArray());
391  static {
392  _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
393  for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
394  _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
395  }
396  }
397 }
it.unical.mat.parsers.asp.clingo.ClingoParser
Definition: ClingoParser.java:13
it.unical.mat.parsers.asp.clingo.ClingoParser.tokenNames
static final String[] tokenNames
Definition: ClingoParser.java:42