EmbASP-Java
DLVHEXParser.java
1 package it.unical.mat.parsers.asp.dlvhex;
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 DLVHEXParser 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, WHITE_SPACE=2, COLON=3, COMMA=4, COST_BEGIN=5, COST_END=6, INTEGER=7,
21  LEVEL_BEGIN=8, LEVEL_END=9, GROUND_QUERY_BEGIN=10, ANSWER_SET_BEGIN=11,
22  ANSWER_SET_END=12, IDENTIFIER=13, STRING_CONSTANT=14, TERMS_BEGIN=15,
23  TERMS_END=16, REASONING=17, DOT=18, BOOLEAN=19, WHITESPACE_IN_GROUND_QUERY=20,
24  WITNESS_LABEL=21;
25  public static final int
26  RULE_answer_set = 0, RULE_atoms = 1, RULE_cost = 2, RULE_level = 3, RULE_output = 4,
27  RULE_predicate_atom = 5, RULE_term = 6, RULE_witness = 7;
28  public static final String[] ruleNames = {
29  "answer_set", "atoms", "cost", "level", "output", "predicate_atom", "term",
30  "witness"
31  };
32 
33  private static final String[] _LITERAL_NAMES = {
34  null, null, null, "':'", "','", "'<'", "'>'", null, "'['", "']'", "' is '",
35  "'{'", "'}'", null, null, "'('", "')'", null, "'.'", null, null, "', evidenced by'"
36  };
37  private static final String[] _SYMBOLIC_NAMES = {
38  null, "HEADER", "WHITE_SPACE", "COLON", "COMMA", "COST_BEGIN", "COST_END",
39  "INTEGER", "LEVEL_BEGIN", "LEVEL_END", "GROUND_QUERY_BEGIN", "ANSWER_SET_BEGIN",
40  "ANSWER_SET_END", "IDENTIFIER", "STRING_CONSTANT", "TERMS_BEGIN", "TERMS_END",
41  "REASONING", "DOT", "BOOLEAN", "WHITESPACE_IN_GROUND_QUERY", "WITNESS_LABEL"
42  };
43  public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
44 
48  @Deprecated
49  public static final String[] tokenNames;
50  static {
51  tokenNames = new String[_SYMBOLIC_NAMES.length];
52  for (int i = 0; i < tokenNames.length; i++) {
53  tokenNames[i] = VOCABULARY.getLiteralName(i);
54  if (tokenNames[i] == null) {
55  tokenNames[i] = VOCABULARY.getSymbolicName(i);
56  }
57 
58  if (tokenNames[i] == null) {
59  tokenNames[i] = "<INVALID>";
60  }
61  }
62  }
63 
64  @Override
65  @Deprecated
66  public String[] getTokenNames() {
67  return tokenNames;
68  }
69 
70  @Override
71 
72  public Vocabulary getVocabulary() {
73  return VOCABULARY;
74  }
75 
76  @Override
77  public String getGrammarFileName() { return "DLVHEXParser.g4"; }
78 
79  @Override
80  public String[] getRuleNames() { return ruleNames; }
81 
82  @Override
83  public String getSerializedATN() { return _serializedATN; }
84 
85  @Override
86  public ATN getATN() { return _ATN; }
87 
88  public DLVHEXParser(TokenStream input) {
89  super(input);
90  _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
91  }
92  public static class Answer_setContext extends ParserRuleContext {
93  public Answer_setContext(ParserRuleContext parent, int invokingState) {
94  super(parent, invokingState);
95  }
96  @Override public int getRuleIndex() { return RULE_answer_set; }
97 
98  public Answer_setContext() { }
99  public void copyFrom(Answer_setContext ctx) {
100  super.copyFrom(ctx);
101  }
102  }
103  public static class GroundQueryContext extends Answer_setContext {
104  public List<TerminalNode> IDENTIFIER() { return getTokens(DLVHEXParser.IDENTIFIER); }
105  public TerminalNode IDENTIFIER(int i) {
106  return getToken(DLVHEXParser.IDENTIFIER, i);
107  }
108  public TerminalNode GROUND_QUERY_BEGIN() { return getToken(DLVHEXParser.GROUND_QUERY_BEGIN, 0); }
109  public TerminalNode REASONING() { return getToken(DLVHEXParser.REASONING, 0); }
110  public TerminalNode BOOLEAN() { return getToken(DLVHEXParser.BOOLEAN, 0); }
111  public TerminalNode DOT() { return getToken(DLVHEXParser.DOT, 0); }
112  public WitnessContext witness() {
113  return getRuleContext(WitnessContext.class,0);
114  }
115  public List<TerminalNode> COMMA() { return getTokens(DLVHEXParser.COMMA); }
116  public TerminalNode COMMA(int i) {
117  return getToken(DLVHEXParser.COMMA, i);
118  }
119  public GroundQueryContext(Answer_setContext ctx) { copyFrom(ctx); }
120  @Override
121  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
122  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitGroundQuery(this);
123  else return visitor.visitChildren(this);
124  }
125  }
126  public static class ModelContext extends Answer_setContext {
127  public AtomsContext atoms() {
128  return getRuleContext(AtomsContext.class,0);
129  }
130  public ModelContext(Answer_setContext ctx) { copyFrom(ctx); }
131  @Override
132  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
133  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitModel(this);
134  else return visitor.visitChildren(this);
135  }
136  }
137 
138  public final Answer_setContext answer_set() throws RecognitionException {
139  Answer_setContext _localctx = new Answer_setContext(_ctx, getState());
140  enterRule(_localctx, 0, RULE_answer_set);
141  int _la;
142  try {
143  setState(32);
144  _errHandler.sync(this);
145  switch (_input.LA(1)) {
146  case IDENTIFIER:
147  _localctx = new GroundQueryContext(_localctx);
148  enterOuterAlt(_localctx, 1);
149  {
150  setState(16);
151  match(IDENTIFIER);
152  setState(21);
153  _errHandler.sync(this);
154  _la = _input.LA(1);
155  while (_la==COMMA) {
156  {
157  {
158  setState(17);
159  match(COMMA);
160  setState(18);
161  match(IDENTIFIER);
162  }
163  }
164  setState(23);
165  _errHandler.sync(this);
166  _la = _input.LA(1);
167  }
168  setState(24);
169  match(GROUND_QUERY_BEGIN);
170  setState(25);
171  match(REASONING);
172  setState(26);
173  match(BOOLEAN);
174  setState(29);
175  _errHandler.sync(this);
176  switch (_input.LA(1)) {
177  case DOT:
178  {
179  setState(27);
180  match(DOT);
181  }
182  break;
183  case WITNESS_LABEL:
184  {
185  setState(28);
186  witness();
187  }
188  break;
189  default:
190  throw new NoViableAltException(this);
191  }
192  }
193  break;
194  case ANSWER_SET_BEGIN:
195  _localctx = new ModelContext(_localctx);
196  enterOuterAlt(_localctx, 2);
197  {
198  setState(31);
199  atoms();
200  }
201  break;
202  default:
203  throw new NoViableAltException(this);
204  }
205  }
206  catch (RecognitionException re) {
207  _localctx.exception = re;
208  _errHandler.reportError(this, re);
209  _errHandler.recover(this, re);
210  }
211  finally {
212  exitRule();
213  }
214  return _localctx;
215  }
216 
217  public static class AtomsContext extends ParserRuleContext {
218  public TerminalNode ANSWER_SET_BEGIN() { return getToken(DLVHEXParser.ANSWER_SET_BEGIN, 0); }
219  public TerminalNode ANSWER_SET_END() { return getToken(DLVHEXParser.ANSWER_SET_END, 0); }
220  public List<Predicate_atomContext> predicate_atom() {
221  return getRuleContexts(Predicate_atomContext.class);
222  }
223  public Predicate_atomContext predicate_atom(int i) {
224  return getRuleContext(Predicate_atomContext.class,i);
225  }
226  public CostContext cost() {
227  return getRuleContext(CostContext.class,0);
228  }
229  public List<TerminalNode> COMMA() { return getTokens(DLVHEXParser.COMMA); }
230  public TerminalNode COMMA(int i) {
231  return getToken(DLVHEXParser.COMMA, i);
232  }
233  public AtomsContext(ParserRuleContext parent, int invokingState) {
234  super(parent, invokingState);
235  }
236  @Override public int getRuleIndex() { return RULE_atoms; }
237  @Override
238  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
239  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitAtoms(this);
240  else return visitor.visitChildren(this);
241  }
242  }
243 
244  public final AtomsContext atoms() throws RecognitionException {
245  AtomsContext _localctx = new AtomsContext(_ctx, getState());
246  enterRule(_localctx, 2, RULE_atoms);
247  int _la;
248  try {
249  enterOuterAlt(_localctx, 1);
250  {
251  setState(34);
252  match(ANSWER_SET_BEGIN);
253  setState(43);
254  _errHandler.sync(this);
255  _la = _input.LA(1);
256  if (_la==IDENTIFIER) {
257  {
258  setState(35);
259  predicate_atom();
260  setState(40);
261  _errHandler.sync(this);
262  _la = _input.LA(1);
263  while (_la==COMMA) {
264  {
265  {
266  setState(36);
267  match(COMMA);
268  setState(37);
269  predicate_atom();
270  }
271  }
272  setState(42);
273  _errHandler.sync(this);
274  _la = _input.LA(1);
275  }
276  }
277  }
278 
279  setState(45);
280  match(ANSWER_SET_END);
281  setState(47);
282  _errHandler.sync(this);
283  _la = _input.LA(1);
284  if (_la==COST_BEGIN) {
285  {
286  setState(46);
287  cost();
288  }
289  }
290 
291  }
292  }
293  catch (RecognitionException re) {
294  _localctx.exception = re;
295  _errHandler.reportError(this, re);
296  _errHandler.recover(this, re);
297  }
298  finally {
299  exitRule();
300  }
301  return _localctx;
302  }
303 
304  public static class CostContext extends ParserRuleContext {
305  public TerminalNode COST_BEGIN() { return getToken(DLVHEXParser.COST_BEGIN, 0); }
306  public List<LevelContext> level() {
307  return getRuleContexts(LevelContext.class);
308  }
309  public LevelContext level(int i) {
310  return getRuleContext(LevelContext.class,i);
311  }
312  public TerminalNode COST_END() { return getToken(DLVHEXParser.COST_END, 0); }
313  public List<TerminalNode> COMMA() { return getTokens(DLVHEXParser.COMMA); }
314  public TerminalNode COMMA(int i) {
315  return getToken(DLVHEXParser.COMMA, i);
316  }
317  public CostContext(ParserRuleContext parent, int invokingState) {
318  super(parent, invokingState);
319  }
320  @Override public int getRuleIndex() { return RULE_cost; }
321  @Override
322  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
323  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitCost(this);
324  else return visitor.visitChildren(this);
325  }
326  }
327 
328  public final CostContext cost() throws RecognitionException {
329  CostContext _localctx = new CostContext(_ctx, getState());
330  enterRule(_localctx, 4, RULE_cost);
331  int _la;
332  try {
333  enterOuterAlt(_localctx, 1);
334  {
335  setState(49);
336  match(COST_BEGIN);
337  setState(50);
338  level();
339  setState(55);
340  _errHandler.sync(this);
341  _la = _input.LA(1);
342  while (_la==COMMA) {
343  {
344  {
345  setState(51);
346  match(COMMA);
347  setState(52);
348  level();
349  }
350  }
351  setState(57);
352  _errHandler.sync(this);
353  _la = _input.LA(1);
354  }
355  setState(58);
356  match(COST_END);
357  }
358  }
359  catch (RecognitionException re) {
360  _localctx.exception = re;
361  _errHandler.reportError(this, re);
362  _errHandler.recover(this, re);
363  }
364  finally {
365  exitRule();
366  }
367  return _localctx;
368  }
369 
370  public static class LevelContext extends ParserRuleContext {
371  public TerminalNode LEVEL_BEGIN() { return getToken(DLVHEXParser.LEVEL_BEGIN, 0); }
372  public List<TerminalNode> INTEGER() { return getTokens(DLVHEXParser.INTEGER); }
373  public TerminalNode INTEGER(int i) {
374  return getToken(DLVHEXParser.INTEGER, i);
375  }
376  public TerminalNode COLON() { return getToken(DLVHEXParser.COLON, 0); }
377  public TerminalNode LEVEL_END() { return getToken(DLVHEXParser.LEVEL_END, 0); }
378  public LevelContext(ParserRuleContext parent, int invokingState) {
379  super(parent, invokingState);
380  }
381  @Override public int getRuleIndex() { return RULE_level; }
382  @Override
383  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
384  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitLevel(this);
385  else return visitor.visitChildren(this);
386  }
387  }
388 
389  public final LevelContext level() throws RecognitionException {
390  LevelContext _localctx = new LevelContext(_ctx, getState());
391  enterRule(_localctx, 6, RULE_level);
392  try {
393  enterOuterAlt(_localctx, 1);
394  {
395  setState(60);
396  match(LEVEL_BEGIN);
397  setState(61);
398  match(INTEGER);
399  setState(62);
400  match(COLON);
401  setState(63);
402  match(INTEGER);
403  setState(64);
404  match(LEVEL_END);
405  }
406  }
407  catch (RecognitionException re) {
408  _localctx.exception = re;
409  _errHandler.reportError(this, re);
410  _errHandler.recover(this, re);
411  }
412  finally {
413  exitRule();
414  }
415  return _localctx;
416  }
417 
418  public static class OutputContext extends ParserRuleContext {
419  public List<Answer_setContext> answer_set() {
420  return getRuleContexts(Answer_setContext.class);
421  }
422  public Answer_setContext answer_set(int i) {
423  return getRuleContext(Answer_setContext.class,i);
424  }
425  public OutputContext(ParserRuleContext parent, int invokingState) {
426  super(parent, invokingState);
427  }
428  @Override public int getRuleIndex() { return RULE_output; }
429  @Override
430  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
431  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitOutput(this);
432  else return visitor.visitChildren(this);
433  }
434  }
435 
436  public final OutputContext output() throws RecognitionException {
437  OutputContext _localctx = new OutputContext(_ctx, getState());
438  enterRule(_localctx, 8, RULE_output);
439  int _la;
440  try {
441  enterOuterAlt(_localctx, 1);
442  {
443  setState(69);
444  _errHandler.sync(this);
445  _la = _input.LA(1);
446  while (_la==ANSWER_SET_BEGIN || _la==IDENTIFIER) {
447  {
448  {
449  setState(66);
450  answer_set();
451  }
452  }
453  setState(71);
454  _errHandler.sync(this);
455  _la = _input.LA(1);
456  }
457  }
458  }
459  catch (RecognitionException re) {
460  _localctx.exception = re;
461  _errHandler.reportError(this, re);
462  _errHandler.recover(this, re);
463  }
464  finally {
465  exitRule();
466  }
467  return _localctx;
468  }
469 
470  public static class Predicate_atomContext extends ParserRuleContext {
471  public TerminalNode IDENTIFIER() { return getToken(DLVHEXParser.IDENTIFIER, 0); }
472  public TerminalNode TERMS_BEGIN() { return getToken(DLVHEXParser.TERMS_BEGIN, 0); }
473  public List<TermContext> term() {
474  return getRuleContexts(TermContext.class);
475  }
476  public TermContext term(int i) {
477  return getRuleContext(TermContext.class,i);
478  }
479  public TerminalNode TERMS_END() { return getToken(DLVHEXParser.TERMS_END, 0); }
480  public List<TerminalNode> COMMA() { return getTokens(DLVHEXParser.COMMA); }
481  public TerminalNode COMMA(int i) {
482  return getToken(DLVHEXParser.COMMA, i);
483  }
484  public Predicate_atomContext(ParserRuleContext parent, int invokingState) {
485  super(parent, invokingState);
486  }
487  @Override public int getRuleIndex() { return RULE_predicate_atom; }
488  @Override
489  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
490  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitPredicate_atom(this);
491  else return visitor.visitChildren(this);
492  }
493  }
494 
495  public final Predicate_atomContext predicate_atom() throws RecognitionException {
496  Predicate_atomContext _localctx = new Predicate_atomContext(_ctx, getState());
497  enterRule(_localctx, 10, RULE_predicate_atom);
498  int _la;
499  try {
500  enterOuterAlt(_localctx, 1);
501  {
502  setState(72);
503  match(IDENTIFIER);
504  setState(84);
505  _errHandler.sync(this);
506  _la = _input.LA(1);
507  if (_la==TERMS_BEGIN) {
508  {
509  setState(73);
510  match(TERMS_BEGIN);
511  setState(74);
512  term();
513  setState(79);
514  _errHandler.sync(this);
515  _la = _input.LA(1);
516  while (_la==COMMA) {
517  {
518  {
519  setState(75);
520  match(COMMA);
521  setState(76);
522  term();
523  }
524  }
525  setState(81);
526  _errHandler.sync(this);
527  _la = _input.LA(1);
528  }
529  setState(82);
530  match(TERMS_END);
531  }
532  }
533 
534  }
535  }
536  catch (RecognitionException re) {
537  _localctx.exception = re;
538  _errHandler.reportError(this, re);
539  _errHandler.recover(this, re);
540  }
541  finally {
542  exitRule();
543  }
544  return _localctx;
545  }
546 
547  public static class TermContext extends ParserRuleContext {
548  public TerminalNode IDENTIFIER() { return getToken(DLVHEXParser.IDENTIFIER, 0); }
549  public TerminalNode INTEGER() { return getToken(DLVHEXParser.INTEGER, 0); }
550  public Predicate_atomContext predicate_atom() {
551  return getRuleContext(Predicate_atomContext.class,0);
552  }
553  public TerminalNode STRING_CONSTANT() { return getToken(DLVHEXParser.STRING_CONSTANT, 0); }
554  public TermContext(ParserRuleContext parent, int invokingState) {
555  super(parent, invokingState);
556  }
557  @Override public int getRuleIndex() { return RULE_term; }
558  @Override
559  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
560  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitTerm(this);
561  else return visitor.visitChildren(this);
562  }
563  }
564 
565  public final TermContext term() throws RecognitionException {
566  TermContext _localctx = new TermContext(_ctx, getState());
567  enterRule(_localctx, 12, RULE_term);
568  try {
569  setState(90);
570  _errHandler.sync(this);
571  switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
572  case 1:
573  enterOuterAlt(_localctx, 1);
574  {
575  setState(86);
576  match(IDENTIFIER);
577  }
578  break;
579  case 2:
580  enterOuterAlt(_localctx, 2);
581  {
582  setState(87);
583  match(INTEGER);
584  }
585  break;
586  case 3:
587  enterOuterAlt(_localctx, 3);
588  {
589  setState(88);
590  predicate_atom();
591  }
592  break;
593  case 4:
594  enterOuterAlt(_localctx, 4);
595  {
596  setState(89);
597  match(STRING_CONSTANT);
598  }
599  break;
600  }
601  }
602  catch (RecognitionException re) {
603  _localctx.exception = re;
604  _errHandler.reportError(this, re);
605  _errHandler.recover(this, re);
606  }
607  finally {
608  exitRule();
609  }
610  return _localctx;
611  }
612 
613  public static class WitnessContext extends ParserRuleContext {
614  public TerminalNode WITNESS_LABEL() { return getToken(DLVHEXParser.WITNESS_LABEL, 0); }
615  public AtomsContext atoms() {
616  return getRuleContext(AtomsContext.class,0);
617  }
618  public WitnessContext(ParserRuleContext parent, int invokingState) {
619  super(parent, invokingState);
620  }
621  @Override public int getRuleIndex() { return RULE_witness; }
622  @Override
623  public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
624  if ( visitor instanceof DLVHEXParserVisitor ) return ((DLVHEXParserVisitor<? extends T>)visitor).visitWitness(this);
625  else return visitor.visitChildren(this);
626  }
627  }
628 
629  public final WitnessContext witness() throws RecognitionException {
630  WitnessContext _localctx = new WitnessContext(_ctx, getState());
631  enterRule(_localctx, 14, RULE_witness);
632  try {
633  enterOuterAlt(_localctx, 1);
634  {
635  setState(92);
636  match(WITNESS_LABEL);
637  setState(93);
638  atoms();
639  }
640  }
641  catch (RecognitionException re) {
642  _localctx.exception = re;
643  _errHandler.reportError(this, re);
644  _errHandler.recover(this, re);
645  }
646  finally {
647  exitRule();
648  }
649  return _localctx;
650  }
651 
652  public static final String _serializedATN =
653  "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\27b\4\2\t\2\4\3\t"+
654  "\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"+
655  "\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\5\2#\n\2\3\3\3"+
656  "\3\3\3\3\3\7\3)\n\3\f\3\16\3,\13\3\5\3.\n\3\3\3\3\3\5\3\62\n\3\3\4\3\4"+
657  "\3\4\3\4\7\48\n\4\f\4\16\4;\13\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\7"+
658  "\6F\n\6\f\6\16\6I\13\6\3\7\3\7\3\7\3\7\3\7\7\7P\n\7\f\7\16\7S\13\7\3\7"+
659  "\3\7\5\7W\n\7\3\b\3\b\3\b\3\b\5\b]\n\b\3\t\3\t\3\t\3\t\2\2\n\2\4\6\b\n"+
660  "\f\16\20\2\2\2f\2\"\3\2\2\2\4$\3\2\2\2\6\63\3\2\2\2\b>\3\2\2\2\nG\3\2"+
661  "\2\2\fJ\3\2\2\2\16\\\3\2\2\2\20^\3\2\2\2\22\27\7\17\2\2\23\24\7\6\2\2"+
662  "\24\26\7\17\2\2\25\23\3\2\2\2\26\31\3\2\2\2\27\25\3\2\2\2\27\30\3\2\2"+
663  "\2\30\32\3\2\2\2\31\27\3\2\2\2\32\33\7\f\2\2\33\34\7\23\2\2\34\37\7\25"+
664  "\2\2\35 \7\24\2\2\36 \5\20\t\2\37\35\3\2\2\2\37\36\3\2\2\2 #\3\2\2\2!"+
665  "#\5\4\3\2\"\22\3\2\2\2\"!\3\2\2\2#\3\3\2\2\2$-\7\r\2\2%*\5\f\7\2&\'\7"+
666  "\6\2\2\')\5\f\7\2(&\3\2\2\2),\3\2\2\2*(\3\2\2\2*+\3\2\2\2+.\3\2\2\2,*"+
667  "\3\2\2\2-%\3\2\2\2-.\3\2\2\2./\3\2\2\2/\61\7\16\2\2\60\62\5\6\4\2\61\60"+
668  "\3\2\2\2\61\62\3\2\2\2\62\5\3\2\2\2\63\64\7\7\2\2\649\5\b\5\2\65\66\7"+
669  "\6\2\2\668\5\b\5\2\67\65\3\2\2\28;\3\2\2\29\67\3\2\2\29:\3\2\2\2:<\3\2"+
670  "\2\2;9\3\2\2\2<=\7\b\2\2=\7\3\2\2\2>?\7\n\2\2?@\7\t\2\2@A\7\5\2\2AB\7"+
671  "\t\2\2BC\7\13\2\2C\t\3\2\2\2DF\5\2\2\2ED\3\2\2\2FI\3\2\2\2GE\3\2\2\2G"+
672  "H\3\2\2\2H\13\3\2\2\2IG\3\2\2\2JV\7\17\2\2KL\7\21\2\2LQ\5\16\b\2MN\7\6"+
673  "\2\2NP\5\16\b\2OM\3\2\2\2PS\3\2\2\2QO\3\2\2\2QR\3\2\2\2RT\3\2\2\2SQ\3"+
674  "\2\2\2TU\7\22\2\2UW\3\2\2\2VK\3\2\2\2VW\3\2\2\2W\r\3\2\2\2X]\7\17\2\2"+
675  "Y]\7\t\2\2Z]\5\f\7\2[]\7\20\2\2\\X\3\2\2\2\\Y\3\2\2\2\\Z\3\2\2\2\\[\3"+
676  "\2\2\2]\17\3\2\2\2^_\7\27\2\2_`\5\4\3\2`\21\3\2\2\2\r\27\37\"*-\619GQ"+
677  "V\\";
678  public static final ATN _ATN =
679  new ATNDeserializer().deserialize(_serializedATN.toCharArray());
680  static {
681  _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
682  for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
683  _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
684  }
685  }
686 }
it.unical.mat.parsers.asp.dlvhex.DLVHEXParser.tokenNames
static final String[] tokenNames
Definition: DLVHEXParser.java:49
it.unical.mat.parsers.asp.dlvhex.DLVHEXParser
Definition: DLVHEXParser.java:13