EmbASP-Java
DLVParser.java
1 package it.unical.mat.parsers.asp.dlv;
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 DLVParser 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  HEADER=1, COLON=2, COST_BEGIN=3, COST_END=4, OPEN_SQUARE_BRACKET=5, CLOSE_SQUARE_BRACKET=6,
21  GROUND_QUERY_BEGIN=7, MODEL_BEGIN=8, MODEL_END=9, WEIGHTED_MODEL_LABEL=10,
22  COMMA=11, IDENTIFIER=12, INTEGER_CONSTANT=13, STRING_CONSTANT=14, TERMS_BEGIN=15,
23  TERMS_END=16, WHITESPACE=17, REASONING=18, DOT=19, BOOLEAN=20, WHITESPACE_IN_GROUND_QUERY=21,
24  WITNESS_LABEL=22;
25  public static final int
26  RULE_answer_set = 0, RULE_cost = 1, RULE_cost_level = 2, RULE_model = 3,
27  RULE_output = 4, RULE_predicate = 5, RULE_term = 6, RULE_witness = 7;
28  public static final String[] ruleNames = {
29  "answer_set", "cost", "cost_level", "model", "output", "predicate", "term",
30  "witness"
31  };
32 
33  private static final String[] _LITERAL_NAMES = {
34  null, null, "':'", "'Cost ([Weight:Level]): <'", "'>'", "'['", "']'",
35  "' is '", "'{'", "'}'", "'Best model:'", "','", null, null, null, "'('",
36  "')'", null, null, "'.'", null, null, "', evidenced by'"
37  };
38  private static final String[] _SYMBOLIC_NAMES = {
39  null, "HEADER", "COLON", "COST_BEGIN", "COST_END", "OPEN_SQUARE_BRACKET",
40  "CLOSE_SQUARE_BRACKET", "GROUND_QUERY_BEGIN", "MODEL_BEGIN", "MODEL_END",
41  "WEIGHTED_MODEL_LABEL", "COMMA", "IDENTIFIER", "INTEGER_CONSTANT", "STRING_CONSTANT",
42  "TERMS_BEGIN", "TERMS_END", "WHITESPACE", "REASONING", "DOT", "BOOLEAN",
43  "WHITESPACE_IN_GROUND_QUERY", "WITNESS_LABEL"
44  };
45  public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
46 
50  @Deprecated
51  public static final String[] tokenNames;
52  static {
53  tokenNames = new String[_SYMBOLIC_NAMES.length];
54  for (int i = 0; i < tokenNames.length; i++) {
55  tokenNames[i] = VOCABULARY.getLiteralName(i);
56  if (tokenNames[i] == null) {
57  tokenNames[i] = VOCABULARY.getSymbolicName(i);
58  }
59 
60  if (tokenNames[i] == null) {
61  tokenNames[i] = "<INVALID>";
62  }
63  }
64  }
65 
66  @Override
67  @Deprecated
68  public String[] getTokenNames() {
69  return tokenNames;
70  }
71 
72  @Override
73 
74  public Vocabulary getVocabulary() {
75  return VOCABULARY;
76  }
77 
78  @Override
79  public String getGrammarFileName() { return "DLVParser.g4"; }
80 
81  @Override
82  public String[] getRuleNames() { return ruleNames; }
83 
84  @Override
85  public String getSerializedATN() { return _serializedATN; }
86 
87  @Override
88  public ATN getATN() { return _ATN; }
89 
90  public DLVParser(TokenStream input) {
91  super(input);
92  _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
93  }
94  public static class Answer_setContext extends ParserRuleContext {
95  public Answer_setContext(ParserRuleContext parent, int invokingState) {
96  super(parent, invokingState);
97  }
98  @Override public int getRuleIndex() { return RULE_answer_set; }
99 
100  public Answer_setContext() { }
101  public void copyFrom(Answer_setContext ctx) {
102  super.copyFrom(ctx);
103  }
104  }
105  public static class SimpleModelContext extends Answer_setContext {
106  public ModelContext model() {
107  return getRuleContext(ModelContext.class,0);
108  }
109  public SimpleModelContext(Answer_setContext ctx) { copyFrom(ctx); }
110  @Override
111  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
112  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitSimpleModel(this);
113  else return visitor.visitChildren(this);
114  }
115  }
116  public static class GroundQueryContext extends Answer_setContext {
117  public List<TerminalNode> IDENTIFIER() { return getTokens(DLVParser.IDENTIFIER); }
118  public TerminalNode IDENTIFIER(int i) {
119  return getToken(DLVParser.IDENTIFIER, i);
120  }
121  public TerminalNode GROUND_QUERY_BEGIN() { return getToken(DLVParser.GROUND_QUERY_BEGIN, 0); }
122  public TerminalNode REASONING() { return getToken(DLVParser.REASONING, 0); }
123  public TerminalNode BOOLEAN() { return getToken(DLVParser.BOOLEAN, 0); }
124  public TerminalNode DOT() { return getToken(DLVParser.DOT, 0); }
125  public WitnessContext witness() {
126  return getRuleContext(WitnessContext.class,0);
127  }
128  public List<TerminalNode> COMMA() { return getTokens(DLVParser.COMMA); }
129  public TerminalNode COMMA(int i) {
130  return getToken(DLVParser.COMMA, i);
131  }
132  public GroundQueryContext(Answer_setContext ctx) { copyFrom(ctx); }
133  @Override
134  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
135  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitGroundQuery(this);
136  else return visitor.visitChildren(this);
137  }
138  }
139  public static class WeightedModelContext extends Answer_setContext {
140  public ModelContext model() {
141  return getRuleContext(ModelContext.class,0);
142  }
143  public CostContext cost() {
144  return getRuleContext(CostContext.class,0);
145  }
146  public TerminalNode WEIGHTED_MODEL_LABEL() { return getToken(DLVParser.WEIGHTED_MODEL_LABEL, 0); }
147  public WeightedModelContext(Answer_setContext ctx) { copyFrom(ctx); }
148  @Override
149  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
150  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitWeightedModel(this);
151  else return visitor.visitChildren(this);
152  }
153  }
154  public static class NonGroundQueryContext extends Answer_setContext {
155  public List<TermContext> term() {
156  return getRuleContexts(TermContext.class);
157  }
158  public TermContext term(int i) {
159  return getRuleContext(TermContext.class,i);
160  }
161  public List<TerminalNode> COMMA() { return getTokens(DLVParser.COMMA); }
162  public TerminalNode COMMA(int i) {
163  return getToken(DLVParser.COMMA, i);
164  }
165  public NonGroundQueryContext(Answer_setContext ctx) { copyFrom(ctx); }
166  @Override
167  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
168  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitNonGroundQuery(this);
169  else return visitor.visitChildren(this);
170  }
171  }
172 
173  public final Answer_setContext answer_set() throws RecognitionException {
174  Answer_setContext _localctx = new Answer_setContext(_ctx, getState());
175  enterRule(_localctx, 0, RULE_answer_set);
176  int _la;
177  try {
178  setState(46);
179  _errHandler.sync(this);
180  switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
181  case 1:
182  _localctx = new GroundQueryContext(_localctx);
183  enterOuterAlt(_localctx, 1);
184  {
185  setState(16);
186  match(IDENTIFIER);
187  setState(21);
188  _errHandler.sync(this);
189  _la = _input.LA(1);
190  while (_la==COMMA) {
191  {
192  {
193  setState(17);
194  match(COMMA);
195  setState(18);
196  match(IDENTIFIER);
197  }
198  }
199  setState(23);
200  _errHandler.sync(this);
201  _la = _input.LA(1);
202  }
203  setState(24);
204  match(GROUND_QUERY_BEGIN);
205  setState(25);
206  match(REASONING);
207  setState(26);
208  match(BOOLEAN);
209  setState(29);
210  _errHandler.sync(this);
211  switch (_input.LA(1)) {
212  case DOT:
213  {
214  setState(27);
215  match(DOT);
216  }
217  break;
218  case WITNESS_LABEL:
219  {
220  setState(28);
221  witness();
222  }
223  break;
224  default:
225  throw new NoViableAltException(this);
226  }
227  }
228  break;
229  case 2:
230  _localctx = new SimpleModelContext(_localctx);
231  enterOuterAlt(_localctx, 2);
232  {
233  setState(31);
234  model();
235  }
236  break;
237  case 3:
238  _localctx = new NonGroundQueryContext(_localctx);
239  enterOuterAlt(_localctx, 3);
240  {
241  setState(32);
242  term();
243  setState(37);
244  _errHandler.sync(this);
245  _la = _input.LA(1);
246  while (_la==COMMA) {
247  {
248  {
249  setState(33);
250  match(COMMA);
251  setState(34);
252  term();
253  }
254  }
255  setState(39);
256  _errHandler.sync(this);
257  _la = _input.LA(1);
258  }
259  }
260  break;
261  case 4:
262  _localctx = new WeightedModelContext(_localctx);
263  enterOuterAlt(_localctx, 4);
264  {
265  setState(41);
266  _errHandler.sync(this);
267  _la = _input.LA(1);
268  if (_la==WEIGHTED_MODEL_LABEL) {
269  {
270  setState(40);
271  match(WEIGHTED_MODEL_LABEL);
272  }
273  }
274 
275  setState(43);
276  model();
277  setState(44);
278  cost();
279  }
280  break;
281  }
282  }
283  catch (RecognitionException re) {
284  _localctx.exception = re;
285  _errHandler.reportError(this, re);
286  _errHandler.recover(this, re);
287  }
288  finally {
289  exitRule();
290  }
291  return _localctx;
292  }
293 
294  public static class CostContext extends ParserRuleContext {
295  public TerminalNode COST_BEGIN() { return getToken(DLVParser.COST_BEGIN, 0); }
296  public List<Cost_levelContext> cost_level() {
297  return getRuleContexts(Cost_levelContext.class);
298  }
299  public Cost_levelContext cost_level(int i) {
300  return getRuleContext(Cost_levelContext.class,i);
301  }
302  public TerminalNode COST_END() { return getToken(DLVParser.COST_END, 0); }
303  public List<TerminalNode> COMMA() { return getTokens(DLVParser.COMMA); }
304  public TerminalNode COMMA(int i) {
305  return getToken(DLVParser.COMMA, i);
306  }
307  public CostContext(ParserRuleContext parent, int invokingState) {
308  super(parent, invokingState);
309  }
310  @Override public int getRuleIndex() { return RULE_cost; }
311  @Override
312  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
313  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitCost(this);
314  else return visitor.visitChildren(this);
315  }
316  }
317 
318  public final CostContext cost() throws RecognitionException {
319  CostContext _localctx = new CostContext(_ctx, getState());
320  enterRule(_localctx, 2, RULE_cost);
321  int _la;
322  try {
323  enterOuterAlt(_localctx, 1);
324  {
325  setState(48);
326  match(COST_BEGIN);
327  setState(49);
328  cost_level();
329  setState(54);
330  _errHandler.sync(this);
331  _la = _input.LA(1);
332  while (_la==COMMA) {
333  {
334  {
335  setState(50);
336  match(COMMA);
337  setState(51);
338  cost_level();
339  }
340  }
341  setState(56);
342  _errHandler.sync(this);
343  _la = _input.LA(1);
344  }
345  setState(57);
346  match(COST_END);
347  }
348  }
349  catch (RecognitionException re) {
350  _localctx.exception = re;
351  _errHandler.reportError(this, re);
352  _errHandler.recover(this, re);
353  }
354  finally {
355  exitRule();
356  }
357  return _localctx;
358  }
359 
360  public static class Cost_levelContext extends ParserRuleContext {
361  public TerminalNode OPEN_SQUARE_BRACKET() { return getToken(DLVParser.OPEN_SQUARE_BRACKET, 0); }
362  public List<TerminalNode> INTEGER_CONSTANT() { return getTokens(DLVParser.INTEGER_CONSTANT); }
363  public TerminalNode INTEGER_CONSTANT(int i) {
364  return getToken(DLVParser.INTEGER_CONSTANT, i);
365  }
366  public TerminalNode COLON() { return getToken(DLVParser.COLON, 0); }
367  public TerminalNode CLOSE_SQUARE_BRACKET() { return getToken(DLVParser.CLOSE_SQUARE_BRACKET, 0); }
368  public Cost_levelContext(ParserRuleContext parent, int invokingState) {
369  super(parent, invokingState);
370  }
371  @Override public int getRuleIndex() { return RULE_cost_level; }
372  @Override
373  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
374  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitCost_level(this);
375  else return visitor.visitChildren(this);
376  }
377  }
378 
379  public final Cost_levelContext cost_level() throws RecognitionException {
380  Cost_levelContext _localctx = new Cost_levelContext(_ctx, getState());
381  enterRule(_localctx, 4, RULE_cost_level);
382  try {
383  enterOuterAlt(_localctx, 1);
384  {
385  setState(59);
386  match(OPEN_SQUARE_BRACKET);
387  setState(60);
388  match(INTEGER_CONSTANT);
389  setState(61);
390  match(COLON);
391  setState(62);
392  match(INTEGER_CONSTANT);
393  setState(63);
394  match(CLOSE_SQUARE_BRACKET);
395  }
396  }
397  catch (RecognitionException re) {
398  _localctx.exception = re;
399  _errHandler.reportError(this, re);
400  _errHandler.recover(this, re);
401  }
402  finally {
403  exitRule();
404  }
405  return _localctx;
406  }
407 
408  public static class ModelContext extends ParserRuleContext {
409  public TerminalNode MODEL_BEGIN() { return getToken(DLVParser.MODEL_BEGIN, 0); }
410  public TerminalNode MODEL_END() { return getToken(DLVParser.MODEL_END, 0); }
411  public List<PredicateContext> predicate() {
412  return getRuleContexts(PredicateContext.class);
413  }
414  public PredicateContext predicate(int i) {
415  return getRuleContext(PredicateContext.class,i);
416  }
417  public List<TerminalNode> COMMA() { return getTokens(DLVParser.COMMA); }
418  public TerminalNode COMMA(int i) {
419  return getToken(DLVParser.COMMA, i);
420  }
421  public ModelContext(ParserRuleContext parent, int invokingState) {
422  super(parent, invokingState);
423  }
424  @Override public int getRuleIndex() { return RULE_model; }
425  @Override
426  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
427  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitModel(this);
428  else return visitor.visitChildren(this);
429  }
430  }
431 
432  public final ModelContext model() throws RecognitionException {
433  ModelContext _localctx = new ModelContext(_ctx, getState());
434  enterRule(_localctx, 6, RULE_model);
435  int _la;
436  try {
437  enterOuterAlt(_localctx, 1);
438  {
439  setState(65);
440  match(MODEL_BEGIN);
441  setState(74);
442  _errHandler.sync(this);
443  _la = _input.LA(1);
444  if (_la==IDENTIFIER) {
445  {
446  setState(66);
447  predicate();
448  setState(71);
449  _errHandler.sync(this);
450  _la = _input.LA(1);
451  while (_la==COMMA) {
452  {
453  {
454  setState(67);
455  match(COMMA);
456  setState(68);
457  predicate();
458  }
459  }
460  setState(73);
461  _errHandler.sync(this);
462  _la = _input.LA(1);
463  }
464  }
465  }
466 
467  setState(76);
468  match(MODEL_END);
469  }
470  }
471  catch (RecognitionException re) {
472  _localctx.exception = re;
473  _errHandler.reportError(this, re);
474  _errHandler.recover(this, re);
475  }
476  finally {
477  exitRule();
478  }
479  return _localctx;
480  }
481 
482  public static class OutputContext extends ParserRuleContext {
483  public List<Answer_setContext> answer_set() {
484  return getRuleContexts(Answer_setContext.class);
485  }
486  public Answer_setContext answer_set(int i) {
487  return getRuleContext(Answer_setContext.class,i);
488  }
489  public OutputContext(ParserRuleContext parent, int invokingState) {
490  super(parent, invokingState);
491  }
492  @Override public int getRuleIndex() { return RULE_output; }
493  @Override
494  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
495  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitOutput(this);
496  else return visitor.visitChildren(this);
497  }
498  }
499 
500  public final OutputContext output() throws RecognitionException {
501  OutputContext _localctx = new OutputContext(_ctx, getState());
502  enterRule(_localctx, 8, RULE_output);
503  int _la;
504  try {
505  enterOuterAlt(_localctx, 1);
506  {
507  setState(81);
508  _errHandler.sync(this);
509  _la = _input.LA(1);
510  while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPEN_SQUARE_BRACKET) | (1L << MODEL_BEGIN) | (1L << WEIGHTED_MODEL_LABEL) | (1L << IDENTIFIER) | (1L << INTEGER_CONSTANT) | (1L << STRING_CONSTANT))) != 0)) {
511  {
512  {
513  setState(78);
514  answer_set();
515  }
516  }
517  setState(83);
518  _errHandler.sync(this);
519  _la = _input.LA(1);
520  }
521  }
522  }
523  catch (RecognitionException re) {
524  _localctx.exception = re;
525  _errHandler.reportError(this, re);
526  _errHandler.recover(this, re);
527  }
528  finally {
529  exitRule();
530  }
531  return _localctx;
532  }
533 
534  public static class PredicateContext extends ParserRuleContext {
535  public TerminalNode IDENTIFIER() { return getToken(DLVParser.IDENTIFIER, 0); }
536  public TerminalNode TERMS_BEGIN() { return getToken(DLVParser.TERMS_BEGIN, 0); }
537  public List<TermContext> term() {
538  return getRuleContexts(TermContext.class);
539  }
540  public TermContext term(int i) {
541  return getRuleContext(TermContext.class,i);
542  }
543  public TerminalNode TERMS_END() { return getToken(DLVParser.TERMS_END, 0); }
544  public List<TerminalNode> COMMA() { return getTokens(DLVParser.COMMA); }
545  public TerminalNode COMMA(int i) {
546  return getToken(DLVParser.COMMA, i);
547  }
548  public PredicateContext(ParserRuleContext parent, int invokingState) {
549  super(parent, invokingState);
550  }
551  @Override public int getRuleIndex() { return RULE_predicate; }
552  @Override
553  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
554  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitPredicate(this);
555  else return visitor.visitChildren(this);
556  }
557  }
558 
559  public final PredicateContext predicate() throws RecognitionException {
560  PredicateContext _localctx = new PredicateContext(_ctx, getState());
561  enterRule(_localctx, 10, RULE_predicate);
562  int _la;
563  try {
564  enterOuterAlt(_localctx, 1);
565  {
566  setState(84);
567  match(IDENTIFIER);
568  setState(96);
569  _errHandler.sync(this);
570  _la = _input.LA(1);
571  if (_la==TERMS_BEGIN) {
572  {
573  setState(85);
574  match(TERMS_BEGIN);
575  setState(86);
576  term();
577  setState(91);
578  _errHandler.sync(this);
579  _la = _input.LA(1);
580  while (_la==COMMA) {
581  {
582  {
583  setState(87);
584  match(COMMA);
585  setState(88);
586  term();
587  }
588  }
589  setState(93);
590  _errHandler.sync(this);
591  _la = _input.LA(1);
592  }
593  setState(94);
594  match(TERMS_END);
595  }
596  }
597 
598  }
599  }
600  catch (RecognitionException re) {
601  _localctx.exception = re;
602  _errHandler.reportError(this, re);
603  _errHandler.recover(this, re);
604  }
605  finally {
606  exitRule();
607  }
608  return _localctx;
609  }
610 
611  public static class TermContext extends ParserRuleContext {
612  public TerminalNode IDENTIFIER() { return getToken(DLVParser.IDENTIFIER, 0); }
613  public TerminalNode INTEGER_CONSTANT() { return getToken(DLVParser.INTEGER_CONSTANT, 0); }
614  public PredicateContext predicate() {
615  return getRuleContext(PredicateContext.class,0);
616  }
617  public TerminalNode OPEN_SQUARE_BRACKET() { return getToken(DLVParser.OPEN_SQUARE_BRACKET, 0); }
618  public TerminalNode CLOSE_SQUARE_BRACKET() { return getToken(DLVParser.CLOSE_SQUARE_BRACKET, 0); }
619  public List<TermContext> term() {
620  return getRuleContexts(TermContext.class);
621  }
622  public TermContext term(int i) {
623  return getRuleContext(TermContext.class,i);
624  }
625  public List<TerminalNode> COMMA() { return getTokens(DLVParser.COMMA); }
626  public TerminalNode COMMA(int i) {
627  return getToken(DLVParser.COMMA, i);
628  }
629  public TerminalNode STRING_CONSTANT() { return getToken(DLVParser.STRING_CONSTANT, 0); }
630  public TermContext(ParserRuleContext parent, int invokingState) {
631  super(parent, invokingState);
632  }
633  @Override public int getRuleIndex() { return RULE_term; }
634  @Override
635  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
636  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitTerm(this);
637  else return visitor.visitChildren(this);
638  }
639  }
640 
641  public final TermContext term() throws RecognitionException {
642  TermContext _localctx = new TermContext(_ctx, getState());
643  enterRule(_localctx, 12, RULE_term);
644  int _la;
645  try {
646  setState(114);
647  _errHandler.sync(this);
648  switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
649  case 1:
650  enterOuterAlt(_localctx, 1);
651  {
652  setState(98);
653  match(IDENTIFIER);
654  }
655  break;
656  case 2:
657  enterOuterAlt(_localctx, 2);
658  {
659  setState(99);
660  match(INTEGER_CONSTANT);
661  }
662  break;
663  case 3:
664  enterOuterAlt(_localctx, 3);
665  {
666  setState(100);
667  predicate();
668  }
669  break;
670  case 4:
671  enterOuterAlt(_localctx, 4);
672  {
673  setState(101);
674  match(OPEN_SQUARE_BRACKET);
675  setState(110);
676  _errHandler.sync(this);
677  _la = _input.LA(1);
678  if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPEN_SQUARE_BRACKET) | (1L << IDENTIFIER) | (1L << INTEGER_CONSTANT) | (1L << STRING_CONSTANT))) != 0)) {
679  {
680  setState(102);
681  term();
682  setState(107);
683  _errHandler.sync(this);
684  _la = _input.LA(1);
685  while (_la==COMMA) {
686  {
687  {
688  setState(103);
689  match(COMMA);
690  setState(104);
691  term();
692  }
693  }
694  setState(109);
695  _errHandler.sync(this);
696  _la = _input.LA(1);
697  }
698  }
699  }
700 
701  setState(112);
702  match(CLOSE_SQUARE_BRACKET);
703  }
704  break;
705  case 5:
706  enterOuterAlt(_localctx, 5);
707  {
708  setState(113);
709  match(STRING_CONSTANT);
710  }
711  break;
712  }
713  }
714  catch (RecognitionException re) {
715  _localctx.exception = re;
716  _errHandler.reportError(this, re);
717  _errHandler.recover(this, re);
718  }
719  finally {
720  exitRule();
721  }
722  return _localctx;
723  }
724 
725  public static class WitnessContext extends ParserRuleContext {
726  public TerminalNode WITNESS_LABEL() { return getToken(DLVParser.WITNESS_LABEL, 0); }
727  public ModelContext model() {
728  return getRuleContext(ModelContext.class,0);
729  }
730  public WitnessContext(ParserRuleContext parent, int invokingState) {
731  super(parent, invokingState);
732  }
733  @Override public int getRuleIndex() { return RULE_witness; }
734  @Override
735  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
736  if ( visitor instanceof DLVParserVisitor ) return ((DLVParserVisitor<? extends T>)visitor).visitWitness(this);
737  else return visitor.visitChildren(this);
738  }
739  }
740 
741  public final WitnessContext witness() throws RecognitionException {
742  WitnessContext _localctx = new WitnessContext(_ctx, getState());
743  enterRule(_localctx, 14, RULE_witness);
744  try {
745  enterOuterAlt(_localctx, 1);
746  {
747  setState(116);
748  match(WITNESS_LABEL);
749  setState(117);
750  model();
751  }
752  }
753  catch (RecognitionException re) {
754  _localctx.exception = re;
755  _errHandler.reportError(this, re);
756  _errHandler.recover(this, re);
757  }
758  finally {
759  exitRule();
760  }
761  return _localctx;
762  }
763 
764  public static final String _serializedATN =
765  "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\30z\4\2\t\2\4\3\t"+
766  "\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\3\2\3\2\7\2\26"+
767  "\n\2\f\2\16\2\31\13\2\3\2\3\2\3\2\3\2\3\2\5\2 \n\2\3\2\3\2\3\2\3\2\7\2"+
768  "&\n\2\f\2\16\2)\13\2\3\2\5\2,\n\2\3\2\3\2\3\2\5\2\61\n\2\3\3\3\3\3\3\3"+
769  "\3\7\3\67\n\3\f\3\16\3:\13\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3"+
770  "\5\3\5\7\5H\n\5\f\5\16\5K\13\5\5\5M\n\5\3\5\3\5\3\6\7\6R\n\6\f\6\16\6"+
771  "U\13\6\3\7\3\7\3\7\3\7\3\7\7\7\\\n\7\f\7\16\7_\13\7\3\7\3\7\5\7c\n\7\3"+
772  "\b\3\b\3\b\3\b\3\b\3\b\3\b\7\bl\n\b\f\b\16\bo\13\b\5\bq\n\b\3\b\3\b\5"+
773  "\bu\n\b\3\t\3\t\3\t\3\t\2\2\n\2\4\6\b\n\f\16\20\2\2\2\u0084\2\60\3\2\2"+
774  "\2\4\62\3\2\2\2\6=\3\2\2\2\bC\3\2\2\2\nS\3\2\2\2\fV\3\2\2\2\16t\3\2\2"+
775  "\2\20v\3\2\2\2\22\27\7\16\2\2\23\24\7\r\2\2\24\26\7\16\2\2\25\23\3\2\2"+
776  "\2\26\31\3\2\2\2\27\25\3\2\2\2\27\30\3\2\2\2\30\32\3\2\2\2\31\27\3\2\2"+
777  "\2\32\33\7\t\2\2\33\34\7\24\2\2\34\37\7\26\2\2\35 \7\25\2\2\36 \5\20\t"+
778  "\2\37\35\3\2\2\2\37\36\3\2\2\2 \61\3\2\2\2!\61\5\b\5\2\"\'\5\16\b\2#$"+
779  "\7\r\2\2$&\5\16\b\2%#\3\2\2\2&)\3\2\2\2\'%\3\2\2\2\'(\3\2\2\2(\61\3\2"+
780  "\2\2)\'\3\2\2\2*,\7\f\2\2+*\3\2\2\2+,\3\2\2\2,-\3\2\2\2-.\5\b\5\2./\5"+
781  "\4\3\2/\61\3\2\2\2\60\22\3\2\2\2\60!\3\2\2\2\60\"\3\2\2\2\60+\3\2\2\2"+
782  "\61\3\3\2\2\2\62\63\7\5\2\2\638\5\6\4\2\64\65\7\r\2\2\65\67\5\6\4\2\66"+
783  "\64\3\2\2\2\67:\3\2\2\28\66\3\2\2\289\3\2\2\29;\3\2\2\2:8\3\2\2\2;<\7"+
784  "\6\2\2<\5\3\2\2\2=>\7\7\2\2>?\7\17\2\2?@\7\4\2\2@A\7\17\2\2AB\7\b\2\2"+
785  "B\7\3\2\2\2CL\7\n\2\2DI\5\f\7\2EF\7\r\2\2FH\5\f\7\2GE\3\2\2\2HK\3\2\2"+
786  "\2IG\3\2\2\2IJ\3\2\2\2JM\3\2\2\2KI\3\2\2\2LD\3\2\2\2LM\3\2\2\2MN\3\2\2"+
787  "\2NO\7\13\2\2O\t\3\2\2\2PR\5\2\2\2QP\3\2\2\2RU\3\2\2\2SQ\3\2\2\2ST\3\2"+
788  "\2\2T\13\3\2\2\2US\3\2\2\2Vb\7\16\2\2WX\7\21\2\2X]\5\16\b\2YZ\7\r\2\2"+
789  "Z\\\5\16\b\2[Y\3\2\2\2\\_\3\2\2\2][\3\2\2\2]^\3\2\2\2^`\3\2\2\2_]\3\2"+
790  "\2\2`a\7\22\2\2ac\3\2\2\2bW\3\2\2\2bc\3\2\2\2c\r\3\2\2\2du\7\16\2\2eu"+
791  "\7\17\2\2fu\5\f\7\2gp\7\7\2\2hm\5\16\b\2ij\7\r\2\2jl\5\16\b\2ki\3\2\2"+
792  "\2lo\3\2\2\2mk\3\2\2\2mn\3\2\2\2nq\3\2\2\2om\3\2\2\2ph\3\2\2\2pq\3\2\2"+
793  "\2qr\3\2\2\2ru\7\b\2\2su\7\20\2\2td\3\2\2\2te\3\2\2\2tf\3\2\2\2tg\3\2"+
794  "\2\2ts\3\2\2\2u\17\3\2\2\2vw\7\30\2\2wx\5\b\5\2x\21\3\2\2\2\20\27\37\'"+
795  "+\608ILS]bmpt";
796  public static final ATN _ATN =
797  new ATNDeserializer().deserialize(_serializedATN.toCharArray());
798  static {
799  _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
800  for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
801  _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
802  }
803  }
804 }
it.unical.mat.parsers.asp.dlv.DLVParser
Definition: DLVParser.java:13
it.unical.mat.parsers.asp.dlv.DLVParser.tokenNames
static final String[] tokenNames
Definition: DLVParser.java:51