EmbASP-CSharp
DLVHEXParser.cs
1 //------------------------------------------------------------------------------
2 // <auto-generated>
3 // This code was generated by a tool.
4 // ANTLR Version: 4.7
5 //
6 // Changes to this file may cause incorrect behavior and will be lost if
7 // the code is regenerated.
8 // </auto-generated>
9 //------------------------------------------------------------------------------
10 
11 // Generated from DLVHEXParser.g4 by ANTLR 4.7
12 
13 // Unreachable code detected
14 #pragma warning disable 0162
15 // The variable '...' is assigned but its value is never used
16 #pragma warning disable 0219
17 // Missing XML comment for publicly visible type or member '...'
18 #pragma warning disable 1591
19 // Ambiguous reference in cref attribute
20 #pragma warning disable 419
21 
22 using System;
23 using System.IO;
24 using System.Text;
25 using System.Diagnostics;
26 using System.Collections.Generic;
27 using Antlr4.Runtime;
28 using Antlr4.Runtime.Atn;
29 using Antlr4.Runtime.Misc;
30 using Antlr4.Runtime.Tree;
31 using DFA = Antlr4.Runtime.Dfa.DFA;
32 
33 [System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7")]
34 [System.CLSCompliant(false)]
35 public partial class DLVHEXParser : Parser {
36  protected static DFA[] decisionToDFA;
37  protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
38  public const int
39  HEADER=1, WHITE_SPACE=2, COLON=3, COMMA=4, COST_BEGIN=5, COST_END=6, INTEGER=7,
40  LEVEL_BEGIN=8, LEVEL_END=9, GROUND_QUERY_BEGIN=10, ANSWER_SET_BEGIN=11,
41  ANSWER_SET_END=12, IDENTIFIER=13, STRING_CONSTANT=14, TERMS_BEGIN=15,
42  TERMS_END=16, REASONING=17, DOT=18, BOOLEAN=19, WHITESPACE_IN_GROUND_QUERY=20,
43  WITNESS_LABEL=21;
44  public const int
45  RULE_answer_set = 0, RULE_atoms = 1, RULE_cost = 2, RULE_level = 3, RULE_output = 4,
46  RULE_predicate_atom = 5, RULE_term = 6, RULE_witness = 7;
47  public static readonly string[] ruleNames = {
48  "answer_set", "atoms", "cost", "level", "output", "predicate_atom", "term",
49  "witness"
50  };
51 
52  private static readonly string[] _LiteralNames = {
53  null, null, null, "':'", "','", "'<'", "'>'", null, "'['", "']'", "' is '",
54  "'{'", "'}'", null, null, "'('", "')'", null, "'.'", null, null, "', evidenced by'"
55  };
56  private static readonly string[] _SymbolicNames = {
57  null, "HEADER", "WHITE_SPACE", "COLON", "COMMA", "COST_BEGIN", "COST_END",
58  "INTEGER", "LEVEL_BEGIN", "LEVEL_END", "GROUND_QUERY_BEGIN", "ANSWER_SET_BEGIN",
59  "ANSWER_SET_END", "IDENTIFIER", "STRING_CONSTANT", "TERMS_BEGIN", "TERMS_END",
60  "REASONING", "DOT", "BOOLEAN", "WHITESPACE_IN_GROUND_QUERY", "WITNESS_LABEL"
61  };
62  public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);
63 
64  [NotNull]
65  public override IVocabulary Vocabulary
66  {
67  get
68  {
69  return DefaultVocabulary;
70  }
71  }
72 
73  public override string GrammarFileName { get { return "DLVHEXParser.g4"; } }
74 
75  public override string[] RuleNames { get { return ruleNames; } }
76 
77  public override string SerializedAtn { get { return new string(_serializedATN); } }
78 
79  static DLVHEXParser() {
80  decisionToDFA = new DFA[_ATN.NumberOfDecisions];
81  for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
82  decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
83  }
84  }
85 
86  public DLVHEXParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }
87 
88  public DLVHEXParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
89  : base(input, output, errorOutput)
90  {
91  Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
92  }
93  public partial class Answer_setContext : ParserRuleContext {
94  public Answer_setContext(ParserRuleContext parent, int invokingState)
95  : base(parent, invokingState)
96  {
97  }
98  public override int RuleIndex { get { return RULE_answer_set; } }
99 
100  public Answer_setContext() { }
101  public virtual void CopyFrom(Answer_setContext context) {
102  base.CopyFrom(context);
103  }
104  }
105  public partial class GroundQueryContext : Answer_setContext {
106  public ITerminalNode[] IDENTIFIER() { return GetTokens(DLVHEXParser.IDENTIFIER); }
107  public ITerminalNode IDENTIFIER(int i) {
108  return GetToken(DLVHEXParser.IDENTIFIER, i);
109  }
110  public ITerminalNode GROUND_QUERY_BEGIN() { return GetToken(DLVHEXParser.GROUND_QUERY_BEGIN, 0); }
111  public ITerminalNode REASONING() { return GetToken(DLVHEXParser.REASONING, 0); }
112  public ITerminalNode BOOLEAN() { return GetToken(DLVHEXParser.BOOLEAN, 0); }
113  public ITerminalNode DOT() { return GetToken(DLVHEXParser.DOT, 0); }
114  public WitnessContext witness() {
115  return GetRuleContext<WitnessContext>(0);
116  }
117  public ITerminalNode[] COMMA() { return GetTokens(DLVHEXParser.COMMA); }
118  public ITerminalNode COMMA(int i) {
119  return GetToken(DLVHEXParser.COMMA, i);
120  }
121  public GroundQueryContext(Answer_setContext context) { CopyFrom(context); }
122  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
124  if (typedVisitor != null) return typedVisitor.VisitGroundQuery(this);
125  else return visitor.VisitChildren(this);
126  }
127  }
128  public partial class ModelContext : Answer_setContext {
129  public AtomsContext atoms() {
130  return GetRuleContext<AtomsContext>(0);
131  }
132  public ModelContext(Answer_setContext context) { CopyFrom(context); }
133  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
135  if (typedVisitor != null) return typedVisitor.VisitModel(this);
136  else return visitor.VisitChildren(this);
137  }
138  }
139 
140  [RuleVersion(0)]
141  public Answer_setContext answer_set() {
142  Answer_setContext _localctx = new Answer_setContext(Context, State);
143  EnterRule(_localctx, 0, RULE_answer_set);
144  int _la;
145  try {
146  State = 32;
147  ErrorHandler.Sync(this);
148  switch (TokenStream.LA(1)) {
149  case IDENTIFIER:
150  _localctx = new GroundQueryContext(_localctx);
151  EnterOuterAlt(_localctx, 1);
152  {
153  State = 16; Match(IDENTIFIER);
154  State = 21;
155  ErrorHandler.Sync(this);
156  _la = TokenStream.LA(1);
157  while (_la==COMMA) {
158  {
159  {
160  State = 17; Match(COMMA);
161  State = 18; Match(IDENTIFIER);
162  }
163  }
164  State = 23;
165  ErrorHandler.Sync(this);
166  _la = TokenStream.LA(1);
167  }
168  State = 24; Match(GROUND_QUERY_BEGIN);
169  State = 25; Match(REASONING);
170  State = 26; Match(BOOLEAN);
171  State = 29;
172  ErrorHandler.Sync(this);
173  switch (TokenStream.LA(1)) {
174  case DOT:
175  {
176  State = 27; Match(DOT);
177  }
178  break;
179  case WITNESS_LABEL:
180  {
181  State = 28; witness();
182  }
183  break;
184  default:
185  throw new NoViableAltException(this);
186  }
187  }
188  break;
189  case ANSWER_SET_BEGIN:
190  _localctx = new ModelContext(_localctx);
191  EnterOuterAlt(_localctx, 2);
192  {
193  State = 31; atoms();
194  }
195  break;
196  default:
197  throw new NoViableAltException(this);
198  }
199  }
200  catch (RecognitionException re) {
201  _localctx.exception = re;
202  ErrorHandler.ReportError(this, re);
203  ErrorHandler.Recover(this, re);
204  }
205  finally {
206  ExitRule();
207  }
208  return _localctx;
209  }
210 
211  public partial class AtomsContext : ParserRuleContext {
212  public ITerminalNode ANSWER_SET_BEGIN() { return GetToken(DLVHEXParser.ANSWER_SET_BEGIN, 0); }
213  public ITerminalNode ANSWER_SET_END() { return GetToken(DLVHEXParser.ANSWER_SET_END, 0); }
214  public Predicate_atomContext[] predicate_atom() {
215  return GetRuleContexts<Predicate_atomContext>();
216  }
217  public Predicate_atomContext predicate_atom(int i) {
218  return GetRuleContext<Predicate_atomContext>(i);
219  }
220  public CostContext cost() {
221  return GetRuleContext<CostContext>(0);
222  }
223  public ITerminalNode[] COMMA() { return GetTokens(DLVHEXParser.COMMA); }
224  public ITerminalNode COMMA(int i) {
225  return GetToken(DLVHEXParser.COMMA, i);
226  }
227  public AtomsContext(ParserRuleContext parent, int invokingState)
228  : base(parent, invokingState)
229  {
230  }
231  public override int RuleIndex { get { return RULE_atoms; } }
232  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
234  if (typedVisitor != null) return typedVisitor.VisitAtoms(this);
235  else return visitor.VisitChildren(this);
236  }
237  }
238 
239  [RuleVersion(0)]
240  public AtomsContext atoms() {
241  AtomsContext _localctx = new AtomsContext(Context, State);
242  EnterRule(_localctx, 2, RULE_atoms);
243  int _la;
244  try {
245  EnterOuterAlt(_localctx, 1);
246  {
247  State = 34; Match(ANSWER_SET_BEGIN);
248  State = 43;
249  ErrorHandler.Sync(this);
250  _la = TokenStream.LA(1);
251  if (_la==IDENTIFIER) {
252  {
253  State = 35; predicate_atom();
254  State = 40;
255  ErrorHandler.Sync(this);
256  _la = TokenStream.LA(1);
257  while (_la==COMMA) {
258  {
259  {
260  State = 36; Match(COMMA);
261  State = 37; predicate_atom();
262  }
263  }
264  State = 42;
265  ErrorHandler.Sync(this);
266  _la = TokenStream.LA(1);
267  }
268  }
269  }
270 
271  State = 45; Match(ANSWER_SET_END);
272  State = 47;
273  ErrorHandler.Sync(this);
274  _la = TokenStream.LA(1);
275  if (_la==COST_BEGIN) {
276  {
277  State = 46; cost();
278  }
279  }
280 
281  }
282  }
283  catch (RecognitionException re) {
284  _localctx.exception = re;
285  ErrorHandler.ReportError(this, re);
286  ErrorHandler.Recover(this, re);
287  }
288  finally {
289  ExitRule();
290  }
291  return _localctx;
292  }
293 
294  public partial class CostContext : ParserRuleContext {
295  public ITerminalNode COST_BEGIN() { return GetToken(DLVHEXParser.COST_BEGIN, 0); }
296  public LevelContext[] level() {
297  return GetRuleContexts<LevelContext>();
298  }
299  public LevelContext level(int i) {
300  return GetRuleContext<LevelContext>(i);
301  }
302  public ITerminalNode COST_END() { return GetToken(DLVHEXParser.COST_END, 0); }
303  public ITerminalNode[] COMMA() { return GetTokens(DLVHEXParser.COMMA); }
304  public ITerminalNode COMMA(int i) {
305  return GetToken(DLVHEXParser.COMMA, i);
306  }
307  public CostContext(ParserRuleContext parent, int invokingState)
308  : base(parent, invokingState)
309  {
310  }
311  public override int RuleIndex { get { return RULE_cost; } }
312  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
314  if (typedVisitor != null) return typedVisitor.VisitCost(this);
315  else return visitor.VisitChildren(this);
316  }
317  }
318 
319  [RuleVersion(0)]
320  public CostContext cost() {
321  CostContext _localctx = new CostContext(Context, State);
322  EnterRule(_localctx, 4, RULE_cost);
323  int _la;
324  try {
325  EnterOuterAlt(_localctx, 1);
326  {
327  State = 49; Match(COST_BEGIN);
328  State = 50; level();
329  State = 55;
330  ErrorHandler.Sync(this);
331  _la = TokenStream.LA(1);
332  while (_la==COMMA) {
333  {
334  {
335  State = 51; Match(COMMA);
336  State = 52; level();
337  }
338  }
339  State = 57;
340  ErrorHandler.Sync(this);
341  _la = TokenStream.LA(1);
342  }
343  State = 58; Match(COST_END);
344  }
345  }
346  catch (RecognitionException re) {
347  _localctx.exception = re;
348  ErrorHandler.ReportError(this, re);
349  ErrorHandler.Recover(this, re);
350  }
351  finally {
352  ExitRule();
353  }
354  return _localctx;
355  }
356 
357  public partial class LevelContext : ParserRuleContext {
358  public ITerminalNode LEVEL_BEGIN() { return GetToken(DLVHEXParser.LEVEL_BEGIN, 0); }
359  public ITerminalNode[] INTEGER() { return GetTokens(DLVHEXParser.INTEGER); }
360  public ITerminalNode INTEGER(int i) {
361  return GetToken(DLVHEXParser.INTEGER, i);
362  }
363  public ITerminalNode COLON() { return GetToken(DLVHEXParser.COLON, 0); }
364  public ITerminalNode LEVEL_END() { return GetToken(DLVHEXParser.LEVEL_END, 0); }
365  public LevelContext(ParserRuleContext parent, int invokingState)
366  : base(parent, invokingState)
367  {
368  }
369  public override int RuleIndex { get { return RULE_level; } }
370  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
372  if (typedVisitor != null) return typedVisitor.VisitLevel(this);
373  else return visitor.VisitChildren(this);
374  }
375  }
376 
377  [RuleVersion(0)]
378  public LevelContext level() {
379  LevelContext _localctx = new LevelContext(Context, State);
380  EnterRule(_localctx, 6, RULE_level);
381  try {
382  EnterOuterAlt(_localctx, 1);
383  {
384  State = 60; Match(LEVEL_BEGIN);
385  State = 61; Match(INTEGER);
386  State = 62; Match(COLON);
387  State = 63; Match(INTEGER);
388  State = 64; Match(LEVEL_END);
389  }
390  }
391  catch (RecognitionException re) {
392  _localctx.exception = re;
393  ErrorHandler.ReportError(this, re);
394  ErrorHandler.Recover(this, re);
395  }
396  finally {
397  ExitRule();
398  }
399  return _localctx;
400  }
401 
402  public partial class OutputContext : ParserRuleContext {
403  public Answer_setContext[] answer_set() {
404  return GetRuleContexts<Answer_setContext>();
405  }
406  public Answer_setContext answer_set(int i) {
407  return GetRuleContext<Answer_setContext>(i);
408  }
409  public OutputContext(ParserRuleContext parent, int invokingState)
410  : base(parent, invokingState)
411  {
412  }
413  public override int RuleIndex { get { return RULE_output; } }
414  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
416  if (typedVisitor != null) return typedVisitor.VisitOutput(this);
417  else return visitor.VisitChildren(this);
418  }
419  }
420 
421  [RuleVersion(0)]
422  public OutputContext output() {
423  OutputContext _localctx = new OutputContext(Context, State);
424  EnterRule(_localctx, 8, RULE_output);
425  int _la;
426  try {
427  EnterOuterAlt(_localctx, 1);
428  {
429  State = 69;
430  ErrorHandler.Sync(this);
431  _la = TokenStream.LA(1);
432  while (_la==ANSWER_SET_BEGIN || _la==IDENTIFIER) {
433  {
434  {
435  State = 66; answer_set();
436  }
437  }
438  State = 71;
439  ErrorHandler.Sync(this);
440  _la = TokenStream.LA(1);
441  }
442  }
443  }
444  catch (RecognitionException re) {
445  _localctx.exception = re;
446  ErrorHandler.ReportError(this, re);
447  ErrorHandler.Recover(this, re);
448  }
449  finally {
450  ExitRule();
451  }
452  return _localctx;
453  }
454 
455  public partial class Predicate_atomContext : ParserRuleContext {
456  public ITerminalNode IDENTIFIER() { return GetToken(DLVHEXParser.IDENTIFIER, 0); }
457  public ITerminalNode TERMS_BEGIN() { return GetToken(DLVHEXParser.TERMS_BEGIN, 0); }
458  public TermContext[] term() {
459  return GetRuleContexts<TermContext>();
460  }
461  public TermContext term(int i) {
462  return GetRuleContext<TermContext>(i);
463  }
464  public ITerminalNode TERMS_END() { return GetToken(DLVHEXParser.TERMS_END, 0); }
465  public ITerminalNode[] COMMA() { return GetTokens(DLVHEXParser.COMMA); }
466  public ITerminalNode COMMA(int i) {
467  return GetToken(DLVHEXParser.COMMA, i);
468  }
469  public Predicate_atomContext(ParserRuleContext parent, int invokingState)
470  : base(parent, invokingState)
471  {
472  }
473  public override int RuleIndex { get { return RULE_predicate_atom; } }
474  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
476  if (typedVisitor != null) return typedVisitor.VisitPredicate_atom(this);
477  else return visitor.VisitChildren(this);
478  }
479  }
480 
481  [RuleVersion(0)]
482  public Predicate_atomContext predicate_atom() {
483  Predicate_atomContext _localctx = new Predicate_atomContext(Context, State);
484  EnterRule(_localctx, 10, RULE_predicate_atom);
485  int _la;
486  try {
487  EnterOuterAlt(_localctx, 1);
488  {
489  State = 72; Match(IDENTIFIER);
490  State = 84;
491  ErrorHandler.Sync(this);
492  _la = TokenStream.LA(1);
493  if (_la==TERMS_BEGIN) {
494  {
495  State = 73; Match(TERMS_BEGIN);
496  State = 74; term();
497  State = 79;
498  ErrorHandler.Sync(this);
499  _la = TokenStream.LA(1);
500  while (_la==COMMA) {
501  {
502  {
503  State = 75; Match(COMMA);
504  State = 76; term();
505  }
506  }
507  State = 81;
508  ErrorHandler.Sync(this);
509  _la = TokenStream.LA(1);
510  }
511  State = 82; Match(TERMS_END);
512  }
513  }
514 
515  }
516  }
517  catch (RecognitionException re) {
518  _localctx.exception = re;
519  ErrorHandler.ReportError(this, re);
520  ErrorHandler.Recover(this, re);
521  }
522  finally {
523  ExitRule();
524  }
525  return _localctx;
526  }
527 
528  public partial class TermContext : ParserRuleContext {
529  public ITerminalNode IDENTIFIER() { return GetToken(DLVHEXParser.IDENTIFIER, 0); }
530  public ITerminalNode INTEGER() { return GetToken(DLVHEXParser.INTEGER, 0); }
531  public Predicate_atomContext predicate_atom() {
532  return GetRuleContext<Predicate_atomContext>(0);
533  }
534  public ITerminalNode STRING_CONSTANT() { return GetToken(DLVHEXParser.STRING_CONSTANT, 0); }
535  public TermContext(ParserRuleContext parent, int invokingState)
536  : base(parent, invokingState)
537  {
538  }
539  public override int RuleIndex { get { return RULE_term; } }
540  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
542  if (typedVisitor != null) return typedVisitor.VisitTerm(this);
543  else return visitor.VisitChildren(this);
544  }
545  }
546 
547  [RuleVersion(0)]
548  public TermContext term() {
549  TermContext _localctx = new TermContext(Context, State);
550  EnterRule(_localctx, 12, RULE_term);
551  try {
552  State = 90;
553  ErrorHandler.Sync(this);
554  switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) {
555  case 1:
556  EnterOuterAlt(_localctx, 1);
557  {
558  State = 86; Match(IDENTIFIER);
559  }
560  break;
561  case 2:
562  EnterOuterAlt(_localctx, 2);
563  {
564  State = 87; Match(INTEGER);
565  }
566  break;
567  case 3:
568  EnterOuterAlt(_localctx, 3);
569  {
570  State = 88; predicate_atom();
571  }
572  break;
573  case 4:
574  EnterOuterAlt(_localctx, 4);
575  {
576  State = 89; Match(STRING_CONSTANT);
577  }
578  break;
579  }
580  }
581  catch (RecognitionException re) {
582  _localctx.exception = re;
583  ErrorHandler.ReportError(this, re);
584  ErrorHandler.Recover(this, re);
585  }
586  finally {
587  ExitRule();
588  }
589  return _localctx;
590  }
591 
592  public partial class WitnessContext : ParserRuleContext {
593  public ITerminalNode WITNESS_LABEL() { return GetToken(DLVHEXParser.WITNESS_LABEL, 0); }
594  public AtomsContext atoms() {
595  return GetRuleContext<AtomsContext>(0);
596  }
597  public WitnessContext(ParserRuleContext parent, int invokingState)
598  : base(parent, invokingState)
599  {
600  }
601  public override int RuleIndex { get { return RULE_witness; } }
602  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
604  if (typedVisitor != null) return typedVisitor.VisitWitness(this);
605  else return visitor.VisitChildren(this);
606  }
607  }
608 
609  [RuleVersion(0)]
610  public WitnessContext witness() {
611  WitnessContext _localctx = new WitnessContext(Context, State);
612  EnterRule(_localctx, 14, RULE_witness);
613  try {
614  EnterOuterAlt(_localctx, 1);
615  {
616  State = 92; Match(WITNESS_LABEL);
617  State = 93; atoms();
618  }
619  }
620  catch (RecognitionException re) {
621  _localctx.exception = re;
622  ErrorHandler.ReportError(this, re);
623  ErrorHandler.Recover(this, re);
624  }
625  finally {
626  ExitRule();
627  }
628  return _localctx;
629  }
630 
631  private static char[] _serializedATN = {
632  '\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786',
633  '\x5964', '\x3', '\x17', '\x62', '\x4', '\x2', '\t', '\x2', '\x4', '\x3',
634  '\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', '\x5', '\x4',
635  '\x6', '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', '\t', '\b',
636  '\x4', '\t', '\t', '\t', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\a',
637  '\x2', '\x16', '\n', '\x2', '\f', '\x2', '\xE', '\x2', '\x19', '\v', '\x2',
638  '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2',
639  '\x5', '\x2', ' ', '\n', '\x2', '\x3', '\x2', '\x5', '\x2', '#', '\n',
640  '\x2', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\a', '\x3',
641  ')', '\n', '\x3', '\f', '\x3', '\xE', '\x3', ',', '\v', '\x3', '\x5',
642  '\x3', '.', '\n', '\x3', '\x3', '\x3', '\x3', '\x3', '\x5', '\x3', '\x32',
643  '\n', '\x3', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\a',
644  '\x4', '\x38', '\n', '\x4', '\f', '\x4', '\xE', '\x4', ';', '\v', '\x4',
645  '\x3', '\x4', '\x3', '\x4', '\x3', '\x5', '\x3', '\x5', '\x3', '\x5',
646  '\x3', '\x5', '\x3', '\x5', '\x3', '\x5', '\x3', '\x6', '\a', '\x6', '\x46',
647  '\n', '\x6', '\f', '\x6', '\xE', '\x6', 'I', '\v', '\x6', '\x3', '\a',
648  '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x3', '\a', '\a', '\a', 'P', '\n',
649  '\a', '\f', '\a', '\xE', '\a', 'S', '\v', '\a', '\x3', '\a', '\x3', '\a',
650  '\x5', '\a', 'W', '\n', '\a', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3',
651  '\b', '\x5', '\b', ']', '\n', '\b', '\x3', '\t', '\x3', '\t', '\x3', '\t',
652  '\x3', '\t', '\x2', '\x2', '\n', '\x2', '\x4', '\x6', '\b', '\n', '\f',
653  '\xE', '\x10', '\x2', '\x2', '\x2', '\x66', '\x2', '\"', '\x3', '\x2',
654  '\x2', '\x2', '\x4', '$', '\x3', '\x2', '\x2', '\x2', '\x6', '\x33', '\x3',
655  '\x2', '\x2', '\x2', '\b', '>', '\x3', '\x2', '\x2', '\x2', '\n', 'G',
656  '\x3', '\x2', '\x2', '\x2', '\f', 'J', '\x3', '\x2', '\x2', '\x2', '\xE',
657  '\\', '\x3', '\x2', '\x2', '\x2', '\x10', '^', '\x3', '\x2', '\x2', '\x2',
658  '\x12', '\x17', '\a', '\xF', '\x2', '\x2', '\x13', '\x14', '\a', '\x6',
659  '\x2', '\x2', '\x14', '\x16', '\a', '\xF', '\x2', '\x2', '\x15', '\x13',
660  '\x3', '\x2', '\x2', '\x2', '\x16', '\x19', '\x3', '\x2', '\x2', '\x2',
661  '\x17', '\x15', '\x3', '\x2', '\x2', '\x2', '\x17', '\x18', '\x3', '\x2',
662  '\x2', '\x2', '\x18', '\x1A', '\x3', '\x2', '\x2', '\x2', '\x19', '\x17',
663  '\x3', '\x2', '\x2', '\x2', '\x1A', '\x1B', '\a', '\f', '\x2', '\x2',
664  '\x1B', '\x1C', '\a', '\x13', '\x2', '\x2', '\x1C', '\x1F', '\a', '\x15',
665  '\x2', '\x2', '\x1D', ' ', '\a', '\x14', '\x2', '\x2', '\x1E', ' ', '\x5',
666  '\x10', '\t', '\x2', '\x1F', '\x1D', '\x3', '\x2', '\x2', '\x2', '\x1F',
667  '\x1E', '\x3', '\x2', '\x2', '\x2', ' ', '#', '\x3', '\x2', '\x2', '\x2',
668  '!', '#', '\x5', '\x4', '\x3', '\x2', '\"', '\x12', '\x3', '\x2', '\x2',
669  '\x2', '\"', '!', '\x3', '\x2', '\x2', '\x2', '#', '\x3', '\x3', '\x2',
670  '\x2', '\x2', '$', '-', '\a', '\r', '\x2', '\x2', '%', '*', '\x5', '\f',
671  '\a', '\x2', '&', '\'', '\a', '\x6', '\x2', '\x2', '\'', ')', '\x5', '\f',
672  '\a', '\x2', '(', '&', '\x3', '\x2', '\x2', '\x2', ')', ',', '\x3', '\x2',
673  '\x2', '\x2', '*', '(', '\x3', '\x2', '\x2', '\x2', '*', '+', '\x3', '\x2',
674  '\x2', '\x2', '+', '.', '\x3', '\x2', '\x2', '\x2', ',', '*', '\x3', '\x2',
675  '\x2', '\x2', '-', '%', '\x3', '\x2', '\x2', '\x2', '-', '.', '\x3', '\x2',
676  '\x2', '\x2', '.', '/', '\x3', '\x2', '\x2', '\x2', '/', '\x31', '\a',
677  '\xE', '\x2', '\x2', '\x30', '\x32', '\x5', '\x6', '\x4', '\x2', '\x31',
678  '\x30', '\x3', '\x2', '\x2', '\x2', '\x31', '\x32', '\x3', '\x2', '\x2',
679  '\x2', '\x32', '\x5', '\x3', '\x2', '\x2', '\x2', '\x33', '\x34', '\a',
680  '\a', '\x2', '\x2', '\x34', '\x39', '\x5', '\b', '\x5', '\x2', '\x35',
681  '\x36', '\a', '\x6', '\x2', '\x2', '\x36', '\x38', '\x5', '\b', '\x5',
682  '\x2', '\x37', '\x35', '\x3', '\x2', '\x2', '\x2', '\x38', ';', '\x3',
683  '\x2', '\x2', '\x2', '\x39', '\x37', '\x3', '\x2', '\x2', '\x2', '\x39',
684  ':', '\x3', '\x2', '\x2', '\x2', ':', '<', '\x3', '\x2', '\x2', '\x2',
685  ';', '\x39', '\x3', '\x2', '\x2', '\x2', '<', '=', '\a', '\b', '\x2',
686  '\x2', '=', '\a', '\x3', '\x2', '\x2', '\x2', '>', '?', '\a', '\n', '\x2',
687  '\x2', '?', '@', '\a', '\t', '\x2', '\x2', '@', '\x41', '\a', '\x5', '\x2',
688  '\x2', '\x41', '\x42', '\a', '\t', '\x2', '\x2', '\x42', '\x43', '\a',
689  '\v', '\x2', '\x2', '\x43', '\t', '\x3', '\x2', '\x2', '\x2', '\x44',
690  '\x46', '\x5', '\x2', '\x2', '\x2', '\x45', '\x44', '\x3', '\x2', '\x2',
691  '\x2', '\x46', 'I', '\x3', '\x2', '\x2', '\x2', 'G', '\x45', '\x3', '\x2',
692  '\x2', '\x2', 'G', 'H', '\x3', '\x2', '\x2', '\x2', 'H', '\v', '\x3',
693  '\x2', '\x2', '\x2', 'I', 'G', '\x3', '\x2', '\x2', '\x2', 'J', 'V', '\a',
694  '\xF', '\x2', '\x2', 'K', 'L', '\a', '\x11', '\x2', '\x2', 'L', 'Q', '\x5',
695  '\xE', '\b', '\x2', 'M', 'N', '\a', '\x6', '\x2', '\x2', 'N', 'P', '\x5',
696  '\xE', '\b', '\x2', 'O', 'M', '\x3', '\x2', '\x2', '\x2', 'P', 'S', '\x3',
697  '\x2', '\x2', '\x2', 'Q', 'O', '\x3', '\x2', '\x2', '\x2', 'Q', 'R', '\x3',
698  '\x2', '\x2', '\x2', 'R', 'T', '\x3', '\x2', '\x2', '\x2', 'S', 'Q', '\x3',
699  '\x2', '\x2', '\x2', 'T', 'U', '\a', '\x12', '\x2', '\x2', 'U', 'W', '\x3',
700  '\x2', '\x2', '\x2', 'V', 'K', '\x3', '\x2', '\x2', '\x2', 'V', 'W', '\x3',
701  '\x2', '\x2', '\x2', 'W', '\r', '\x3', '\x2', '\x2', '\x2', 'X', ']',
702  '\a', '\xF', '\x2', '\x2', 'Y', ']', '\a', '\t', '\x2', '\x2', 'Z', ']',
703  '\x5', '\f', '\a', '\x2', '[', ']', '\a', '\x10', '\x2', '\x2', '\\',
704  'X', '\x3', '\x2', '\x2', '\x2', '\\', 'Y', '\x3', '\x2', '\x2', '\x2',
705  '\\', 'Z', '\x3', '\x2', '\x2', '\x2', '\\', '[', '\x3', '\x2', '\x2',
706  '\x2', ']', '\xF', '\x3', '\x2', '\x2', '\x2', '^', '_', '\a', '\x17',
707  '\x2', '\x2', '_', '`', '\x5', '\x4', '\x3', '\x2', '`', '\x11', '\x3',
708  '\x2', '\x2', '\x2', '\r', '\x17', '\x1F', '\"', '*', '-', '\x31', '\x39',
709  'G', 'Q', 'V', '\\',
710  };
711 
712  public static readonly ATN _ATN =
713  new ATNDeserializer().Deserialize(_serializedATN);
714 
715 
716 }
base
Definition: Callback.cs:1
IDLVHEXParserVisitor.VisitPredicate_atom
Result VisitPredicate_atom([NotNull] DLVHEXParser.Predicate_atomContext context)
Visit a parse tree produced by DLVHEXParser.predicate_atom.
IDLVHEXParserVisitor.VisitGroundQuery
Result VisitGroundQuery([NotNull] DLVHEXParser.GroundQueryContext context)
Visit a parse tree produced by the GroundQuery labeled alternative in DLVHEXParser....
IDLVHEXParserVisitor.VisitAtoms
Result VisitAtoms([NotNull] DLVHEXParser.AtomsContext context)
Visit a parse tree produced by DLVHEXParser.atoms.
IDLVHEXParserVisitor.VisitCost
Result VisitCost([NotNull] DLVHEXParser.CostContext context)
Visit a parse tree produced by DLVHEXParser.cost.
IDLVHEXParserVisitor.VisitOutput
Result VisitOutput([NotNull] DLVHEXParser.OutputContext context)
Visit a parse tree produced by DLVHEXParser.output.
IDLVHEXParserVisitor.VisitTerm
Result VisitTerm([NotNull] DLVHEXParser.TermContext context)
Visit a parse tree produced by DLVHEXParser.term.
IDLVHEXParserVisitor
This interface defines a complete generic visitor for a parse tree produced by DLVHEXParser.
Definition: DLVHEXParserVisitor.cs:33
IDLVHEXParserVisitor.VisitLevel
Result VisitLevel([NotNull] DLVHEXParser.LevelContext context)
Visit a parse tree produced by DLVHEXParser.level.
IDLVHEXParserVisitor.VisitModel
Result VisitModel([NotNull] DLVHEXParser.ModelContext context)
Visit a parse tree produced by the Model labeled alternative in DLVHEXParser.answer_set.
IDLVHEXParserVisitor.VisitWitness
Result VisitWitness([NotNull] DLVHEXParser.WitnessContext context)
Visit a parse tree produced by DLVHEXParser.witness.