EmbASP-CSharp
DLV2Parser.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 DLV2Parser.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 DLV2Parser : Parser {
36  protected static DFA[] decisionToDFA;
37  protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
38  public const int
39  START=1, COST_LABEL=2, ANY=3, IGNORE=4, AT=5, INTEGER=6, NEW_LINE=7, BLANK_SPACE=8,
40  COMMA=9, INTEGER_CONSTANT=10, IDENTIFIER=11, MODEL_END=12, STRING_CONSTANT=13,
41  TERMS_BEGIN=14, TERMS_END=15, WHITE_SPACE=16;
42  public const int
43  RULE_answer_set = 0, RULE_cost = 1, RULE_level = 2, RULE_model = 3, RULE_output = 4,
44  RULE_predicate_atom = 5, RULE_term = 6;
45  public static readonly string[] ruleNames = {
46  "answer_set", "cost", "level", "model", "output", "predicate_atom", "term"
47  };
48 
49  private static readonly string[] _LiteralNames = {
50  null, "'{'", null, null, null, "'@'", null, null, null, "','", null, null,
51  "'}'", null, "'('", "')'"
52  };
53  private static readonly string[] _SymbolicNames = {
54  null, "START", "COST_LABEL", "ANY", "IGNORE", "AT", "INTEGER", "NEW_LINE",
55  "BLANK_SPACE", "COMMA", "INTEGER_CONSTANT", "IDENTIFIER", "MODEL_END",
56  "STRING_CONSTANT", "TERMS_BEGIN", "TERMS_END", "WHITE_SPACE"
57  };
58  public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);
59 
60  [NotNull]
61  public override IVocabulary Vocabulary
62  {
63  get
64  {
65  return DefaultVocabulary;
66  }
67  }
68 
69  public override string GrammarFileName { get { return "DLV2Parser.g4"; } }
70 
71  public override string[] RuleNames { get { return ruleNames; } }
72 
73  public override string SerializedAtn { get { return new string(_serializedATN); } }
74 
75  static DLV2Parser() {
76  decisionToDFA = new DFA[_ATN.NumberOfDecisions];
77  for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
78  decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
79  }
80  }
81 
82  public DLV2Parser(ITokenStream input) : this(input, Console.Out, Console.Error) { }
83 
84  public DLV2Parser(ITokenStream input, TextWriter output, TextWriter errorOutput)
85  : base(input, output, errorOutput)
86  {
87  Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
88  }
89  public partial class Answer_setContext : ParserRuleContext {
90  public ITerminalNode START() { return GetToken(DLV2Parser.START, 0); }
91  public ModelContext model() {
92  return GetRuleContext<ModelContext>(0);
93  }
94  public CostContext cost() {
95  return GetRuleContext<CostContext>(0);
96  }
97  public Answer_setContext(ParserRuleContext parent, int invokingState)
98  : base(parent, invokingState)
99  {
100  }
101  public override int RuleIndex { get { return RULE_answer_set; } }
102  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
104  if (typedVisitor != null) return typedVisitor.VisitAnswer_set(this);
105  else return visitor.VisitChildren(this);
106  }
107  }
108 
109  [RuleVersion(0)]
110  public Answer_setContext answer_set() {
111  Answer_setContext _localctx = new Answer_setContext(Context, State);
112  EnterRule(_localctx, 0, RULE_answer_set);
113  int _la;
114  try {
115  EnterOuterAlt(_localctx, 1);
116  {
117  State = 14; Match(START);
118  State = 15; model();
119  State = 17;
120  ErrorHandler.Sync(this);
121  _la = TokenStream.LA(1);
122  if (_la==COST_LABEL) {
123  {
124  State = 16; cost();
125  }
126  }
127 
128  }
129  }
130  catch (RecognitionException re) {
131  _localctx.exception = re;
132  ErrorHandler.ReportError(this, re);
133  ErrorHandler.Recover(this, re);
134  }
135  finally {
136  ExitRule();
137  }
138  return _localctx;
139  }
140 
141  public partial class CostContext : ParserRuleContext {
142  public ITerminalNode COST_LABEL() { return GetToken(DLV2Parser.COST_LABEL, 0); }
143  public ITerminalNode NEW_LINE() { return GetToken(DLV2Parser.NEW_LINE, 0); }
144  public LevelContext[] level() {
145  return GetRuleContexts<LevelContext>();
146  }
147  public LevelContext level(int i) {
148  return GetRuleContext<LevelContext>(i);
149  }
150  public CostContext(ParserRuleContext parent, int invokingState)
151  : base(parent, invokingState)
152  {
153  }
154  public override int RuleIndex { get { return RULE_cost; } }
155  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
157  if (typedVisitor != null) return typedVisitor.VisitCost(this);
158  else return visitor.VisitChildren(this);
159  }
160  }
161 
162  [RuleVersion(0)]
163  public CostContext cost() {
164  CostContext _localctx = new CostContext(Context, State);
165  EnterRule(_localctx, 2, RULE_cost);
166  int _la;
167  try {
168  EnterOuterAlt(_localctx, 1);
169  {
170  State = 19; Match(COST_LABEL);
171  State = 23;
172  ErrorHandler.Sync(this);
173  _la = TokenStream.LA(1);
174  while (_la==INTEGER) {
175  {
176  {
177  State = 20; level();
178  }
179  }
180  State = 25;
181  ErrorHandler.Sync(this);
182  _la = TokenStream.LA(1);
183  }
184  State = 26; Match(NEW_LINE);
185  }
186  }
187  catch (RecognitionException re) {
188  _localctx.exception = re;
189  ErrorHandler.ReportError(this, re);
190  ErrorHandler.Recover(this, re);
191  }
192  finally {
193  ExitRule();
194  }
195  return _localctx;
196  }
197 
198  public partial class LevelContext : ParserRuleContext {
199  public ITerminalNode[] INTEGER() { return GetTokens(DLV2Parser.INTEGER); }
200  public ITerminalNode INTEGER(int i) {
201  return GetToken(DLV2Parser.INTEGER, i);
202  }
203  public ITerminalNode AT() { return GetToken(DLV2Parser.AT, 0); }
204  public LevelContext(ParserRuleContext parent, int invokingState)
205  : base(parent, invokingState)
206  {
207  }
208  public override int RuleIndex { get { return RULE_level; } }
209  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
211  if (typedVisitor != null) return typedVisitor.VisitLevel(this);
212  else return visitor.VisitChildren(this);
213  }
214  }
215 
216  [RuleVersion(0)]
217  public LevelContext level() {
218  LevelContext _localctx = new LevelContext(Context, State);
219  EnterRule(_localctx, 4, RULE_level);
220  try {
221  EnterOuterAlt(_localctx, 1);
222  {
223  State = 28; Match(INTEGER);
224  State = 29; Match(AT);
225  State = 30; Match(INTEGER);
226  }
227  }
228  catch (RecognitionException re) {
229  _localctx.exception = re;
230  ErrorHandler.ReportError(this, re);
231  ErrorHandler.Recover(this, re);
232  }
233  finally {
234  ExitRule();
235  }
236  return _localctx;
237  }
238 
239  public partial class ModelContext : ParserRuleContext {
240  public ITerminalNode MODEL_END() { return GetToken(DLV2Parser.MODEL_END, 0); }
241  public Predicate_atomContext[] predicate_atom() {
242  return GetRuleContexts<Predicate_atomContext>();
243  }
244  public Predicate_atomContext predicate_atom(int i) {
245  return GetRuleContext<Predicate_atomContext>(i);
246  }
247  public ITerminalNode[] COMMA() { return GetTokens(DLV2Parser.COMMA); }
248  public ITerminalNode COMMA(int i) {
249  return GetToken(DLV2Parser.COMMA, i);
250  }
251  public ModelContext(ParserRuleContext parent, int invokingState)
252  : base(parent, invokingState)
253  {
254  }
255  public override int RuleIndex { get { return RULE_model; } }
256  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
258  if (typedVisitor != null) return typedVisitor.VisitModel(this);
259  else return visitor.VisitChildren(this);
260  }
261  }
262 
263  [RuleVersion(0)]
264  public ModelContext model() {
265  ModelContext _localctx = new ModelContext(Context, State);
266  EnterRule(_localctx, 6, RULE_model);
267  int _la;
268  try {
269  EnterOuterAlt(_localctx, 1);
270  {
271  State = 40;
272  ErrorHandler.Sync(this);
273  _la = TokenStream.LA(1);
274  if (_la==IDENTIFIER) {
275  {
276  State = 32; predicate_atom();
277  State = 37;
278  ErrorHandler.Sync(this);
279  _la = TokenStream.LA(1);
280  while (_la==COMMA) {
281  {
282  {
283  State = 33; Match(COMMA);
284  State = 34; predicate_atom();
285  }
286  }
287  State = 39;
288  ErrorHandler.Sync(this);
289  _la = TokenStream.LA(1);
290  }
291  }
292  }
293 
294  State = 42; Match(MODEL_END);
295  }
296  }
297  catch (RecognitionException re) {
298  _localctx.exception = re;
299  ErrorHandler.ReportError(this, re);
300  ErrorHandler.Recover(this, re);
301  }
302  finally {
303  ExitRule();
304  }
305  return _localctx;
306  }
307 
308  public partial class OutputContext : ParserRuleContext {
309  public Answer_setContext[] answer_set() {
310  return GetRuleContexts<Answer_setContext>();
311  }
312  public Answer_setContext answer_set(int i) {
313  return GetRuleContext<Answer_setContext>(i);
314  }
315  public OutputContext(ParserRuleContext parent, int invokingState)
316  : base(parent, invokingState)
317  {
318  }
319  public override int RuleIndex { get { return RULE_output; } }
320  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
322  if (typedVisitor != null) return typedVisitor.VisitOutput(this);
323  else return visitor.VisitChildren(this);
324  }
325  }
326 
327  [RuleVersion(0)]
328  public OutputContext output() {
329  OutputContext _localctx = new OutputContext(Context, State);
330  EnterRule(_localctx, 8, RULE_output);
331  int _la;
332  try {
333  EnterOuterAlt(_localctx, 1);
334  {
335  State = 47;
336  ErrorHandler.Sync(this);
337  _la = TokenStream.LA(1);
338  while (_la==START) {
339  {
340  {
341  State = 44; answer_set();
342  }
343  }
344  State = 49;
345  ErrorHandler.Sync(this);
346  _la = TokenStream.LA(1);
347  }
348  }
349  }
350  catch (RecognitionException re) {
351  _localctx.exception = re;
352  ErrorHandler.ReportError(this, re);
353  ErrorHandler.Recover(this, re);
354  }
355  finally {
356  ExitRule();
357  }
358  return _localctx;
359  }
360 
361  public partial class Predicate_atomContext : ParserRuleContext {
362  public ITerminalNode IDENTIFIER() { return GetToken(DLV2Parser.IDENTIFIER, 0); }
363  public ITerminalNode TERMS_BEGIN() { return GetToken(DLV2Parser.TERMS_BEGIN, 0); }
364  public TermContext[] term() {
365  return GetRuleContexts<TermContext>();
366  }
367  public TermContext term(int i) {
368  return GetRuleContext<TermContext>(i);
369  }
370  public ITerminalNode TERMS_END() { return GetToken(DLV2Parser.TERMS_END, 0); }
371  public ITerminalNode[] COMMA() { return GetTokens(DLV2Parser.COMMA); }
372  public ITerminalNode COMMA(int i) {
373  return GetToken(DLV2Parser.COMMA, i);
374  }
375  public Predicate_atomContext(ParserRuleContext parent, int invokingState)
376  : base(parent, invokingState)
377  {
378  }
379  public override int RuleIndex { get { return RULE_predicate_atom; } }
380  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
382  if (typedVisitor != null) return typedVisitor.VisitPredicate_atom(this);
383  else return visitor.VisitChildren(this);
384  }
385  }
386 
387  [RuleVersion(0)]
388  public Predicate_atomContext predicate_atom() {
389  Predicate_atomContext _localctx = new Predicate_atomContext(Context, State);
390  EnterRule(_localctx, 10, RULE_predicate_atom);
391  int _la;
392  try {
393  EnterOuterAlt(_localctx, 1);
394  {
395  State = 50; Match(IDENTIFIER);
396  State = 62;
397  ErrorHandler.Sync(this);
398  _la = TokenStream.LA(1);
399  if (_la==TERMS_BEGIN) {
400  {
401  State = 51; Match(TERMS_BEGIN);
402  State = 52; term();
403  State = 57;
404  ErrorHandler.Sync(this);
405  _la = TokenStream.LA(1);
406  while (_la==COMMA) {
407  {
408  {
409  State = 53; Match(COMMA);
410  State = 54; term();
411  }
412  }
413  State = 59;
414  ErrorHandler.Sync(this);
415  _la = TokenStream.LA(1);
416  }
417  State = 60; Match(TERMS_END);
418  }
419  }
420 
421  }
422  }
423  catch (RecognitionException re) {
424  _localctx.exception = re;
425  ErrorHandler.ReportError(this, re);
426  ErrorHandler.Recover(this, re);
427  }
428  finally {
429  ExitRule();
430  }
431  return _localctx;
432  }
433 
434  public partial class TermContext : ParserRuleContext {
435  public ITerminalNode IDENTIFIER() { return GetToken(DLV2Parser.IDENTIFIER, 0); }
436  public ITerminalNode INTEGER_CONSTANT() { return GetToken(DLV2Parser.INTEGER_CONSTANT, 0); }
437  public Predicate_atomContext predicate_atom() {
438  return GetRuleContext<Predicate_atomContext>(0);
439  }
440  public ITerminalNode STRING_CONSTANT() { return GetToken(DLV2Parser.STRING_CONSTANT, 0); }
441  public TermContext(ParserRuleContext parent, int invokingState)
442  : base(parent, invokingState)
443  {
444  }
445  public override int RuleIndex { get { return RULE_term; } }
446  public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
448  if (typedVisitor != null) return typedVisitor.VisitTerm(this);
449  else return visitor.VisitChildren(this);
450  }
451  }
452 
453  [RuleVersion(0)]
454  public TermContext term() {
455  TermContext _localctx = new TermContext(Context, State);
456  EnterRule(_localctx, 12, RULE_term);
457  try {
458  State = 68;
459  ErrorHandler.Sync(this);
460  switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
461  case 1:
462  EnterOuterAlt(_localctx, 1);
463  {
464  State = 64; Match(IDENTIFIER);
465  }
466  break;
467  case 2:
468  EnterOuterAlt(_localctx, 2);
469  {
470  State = 65; Match(INTEGER_CONSTANT);
471  }
472  break;
473  case 3:
474  EnterOuterAlt(_localctx, 3);
475  {
476  State = 66; predicate_atom();
477  }
478  break;
479  case 4:
480  EnterOuterAlt(_localctx, 4);
481  {
482  State = 67; Match(STRING_CONSTANT);
483  }
484  break;
485  }
486  }
487  catch (RecognitionException re) {
488  _localctx.exception = re;
489  ErrorHandler.ReportError(this, re);
490  ErrorHandler.Recover(this, re);
491  }
492  finally {
493  ExitRule();
494  }
495  return _localctx;
496  }
497 
498  private static char[] _serializedATN = {
499  '\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786',
500  '\x5964', '\x3', '\x12', 'I', '\x4', '\x2', '\t', '\x2', '\x4', '\x3',
501  '\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', '\x5', '\x4',
502  '\x6', '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', '\t', '\b',
503  '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x5', '\x2', '\x14', '\n',
504  '\x2', '\x3', '\x3', '\x3', '\x3', '\a', '\x3', '\x18', '\n', '\x3', '\f',
505  '\x3', '\xE', '\x3', '\x1B', '\v', '\x3', '\x3', '\x3', '\x3', '\x3',
506  '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x5',
507  '\x3', '\x5', '\x3', '\x5', '\a', '\x5', '&', '\n', '\x5', '\f', '\x5',
508  '\xE', '\x5', ')', '\v', '\x5', '\x5', '\x5', '+', '\n', '\x5', '\x3',
509  '\x5', '\x3', '\x5', '\x3', '\x6', '\a', '\x6', '\x30', '\n', '\x6', '\f',
510  '\x6', '\xE', '\x6', '\x33', '\v', '\x6', '\x3', '\a', '\x3', '\a', '\x3',
511  '\a', '\x3', '\a', '\x3', '\a', '\a', '\a', ':', '\n', '\a', '\f', '\a',
512  '\xE', '\a', '=', '\v', '\a', '\x3', '\a', '\x3', '\a', '\x5', '\a', '\x41',
513  '\n', '\a', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x5',
514  '\b', 'G', '\n', '\b', '\x3', '\b', '\x2', '\x2', '\t', '\x2', '\x4',
515  '\x6', '\b', '\n', '\f', '\xE', '\x2', '\x2', '\x2', 'K', '\x2', '\x10',
516  '\x3', '\x2', '\x2', '\x2', '\x4', '\x15', '\x3', '\x2', '\x2', '\x2',
517  '\x6', '\x1E', '\x3', '\x2', '\x2', '\x2', '\b', '*', '\x3', '\x2', '\x2',
518  '\x2', '\n', '\x31', '\x3', '\x2', '\x2', '\x2', '\f', '\x34', '\x3',
519  '\x2', '\x2', '\x2', '\xE', '\x46', '\x3', '\x2', '\x2', '\x2', '\x10',
520  '\x11', '\a', '\x3', '\x2', '\x2', '\x11', '\x13', '\x5', '\b', '\x5',
521  '\x2', '\x12', '\x14', '\x5', '\x4', '\x3', '\x2', '\x13', '\x12', '\x3',
522  '\x2', '\x2', '\x2', '\x13', '\x14', '\x3', '\x2', '\x2', '\x2', '\x14',
523  '\x3', '\x3', '\x2', '\x2', '\x2', '\x15', '\x19', '\a', '\x4', '\x2',
524  '\x2', '\x16', '\x18', '\x5', '\x6', '\x4', '\x2', '\x17', '\x16', '\x3',
525  '\x2', '\x2', '\x2', '\x18', '\x1B', '\x3', '\x2', '\x2', '\x2', '\x19',
526  '\x17', '\x3', '\x2', '\x2', '\x2', '\x19', '\x1A', '\x3', '\x2', '\x2',
527  '\x2', '\x1A', '\x1C', '\x3', '\x2', '\x2', '\x2', '\x1B', '\x19', '\x3',
528  '\x2', '\x2', '\x2', '\x1C', '\x1D', '\a', '\t', '\x2', '\x2', '\x1D',
529  '\x5', '\x3', '\x2', '\x2', '\x2', '\x1E', '\x1F', '\a', '\b', '\x2',
530  '\x2', '\x1F', ' ', '\a', '\a', '\x2', '\x2', ' ', '!', '\a', '\b', '\x2',
531  '\x2', '!', '\a', '\x3', '\x2', '\x2', '\x2', '\"', '\'', '\x5', '\f',
532  '\a', '\x2', '#', '$', '\a', '\v', '\x2', '\x2', '$', '&', '\x5', '\f',
533  '\a', '\x2', '%', '#', '\x3', '\x2', '\x2', '\x2', '&', ')', '\x3', '\x2',
534  '\x2', '\x2', '\'', '%', '\x3', '\x2', '\x2', '\x2', '\'', '(', '\x3',
535  '\x2', '\x2', '\x2', '(', '+', '\x3', '\x2', '\x2', '\x2', ')', '\'',
536  '\x3', '\x2', '\x2', '\x2', '*', '\"', '\x3', '\x2', '\x2', '\x2', '*',
537  '+', '\x3', '\x2', '\x2', '\x2', '+', ',', '\x3', '\x2', '\x2', '\x2',
538  ',', '-', '\a', '\xE', '\x2', '\x2', '-', '\t', '\x3', '\x2', '\x2', '\x2',
539  '.', '\x30', '\x5', '\x2', '\x2', '\x2', '/', '.', '\x3', '\x2', '\x2',
540  '\x2', '\x30', '\x33', '\x3', '\x2', '\x2', '\x2', '\x31', '/', '\x3',
541  '\x2', '\x2', '\x2', '\x31', '\x32', '\x3', '\x2', '\x2', '\x2', '\x32',
542  '\v', '\x3', '\x2', '\x2', '\x2', '\x33', '\x31', '\x3', '\x2', '\x2',
543  '\x2', '\x34', '@', '\a', '\r', '\x2', '\x2', '\x35', '\x36', '\a', '\x10',
544  '\x2', '\x2', '\x36', ';', '\x5', '\xE', '\b', '\x2', '\x37', '\x38',
545  '\a', '\v', '\x2', '\x2', '\x38', ':', '\x5', '\xE', '\b', '\x2', '\x39',
546  '\x37', '\x3', '\x2', '\x2', '\x2', ':', '=', '\x3', '\x2', '\x2', '\x2',
547  ';', '\x39', '\x3', '\x2', '\x2', '\x2', ';', '<', '\x3', '\x2', '\x2',
548  '\x2', '<', '>', '\x3', '\x2', '\x2', '\x2', '=', ';', '\x3', '\x2', '\x2',
549  '\x2', '>', '?', '\a', '\x11', '\x2', '\x2', '?', '\x41', '\x3', '\x2',
550  '\x2', '\x2', '@', '\x35', '\x3', '\x2', '\x2', '\x2', '@', '\x41', '\x3',
551  '\x2', '\x2', '\x2', '\x41', '\r', '\x3', '\x2', '\x2', '\x2', '\x42',
552  'G', '\a', '\r', '\x2', '\x2', '\x43', 'G', '\a', '\f', '\x2', '\x2',
553  '\x44', 'G', '\x5', '\f', '\a', '\x2', '\x45', 'G', '\a', '\xF', '\x2',
554  '\x2', '\x46', '\x42', '\x3', '\x2', '\x2', '\x2', '\x46', '\x43', '\x3',
555  '\x2', '\x2', '\x2', '\x46', '\x44', '\x3', '\x2', '\x2', '\x2', '\x46',
556  '\x45', '\x3', '\x2', '\x2', '\x2', 'G', '\xF', '\x3', '\x2', '\x2', '\x2',
557  '\n', '\x13', '\x19', '\'', '*', '\x31', ';', '@', '\x46',
558  };
559 
560  public static readonly ATN _ATN =
561  new ATNDeserializer().Deserialize(_serializedATN);
562 
563 
564 }
IDLV2ParserVisitor
This interface defines a complete generic visitor for a parse tree produced by DLV2Parser.
Definition: DLV2ParserVisitor.cs:33
base
Definition: Callback.cs:1
IDLV2ParserVisitor.VisitPredicate_atom
Result VisitPredicate_atom([NotNull] DLV2Parser.Predicate_atomContext context)
Visit a parse tree produced by DLV2Parser.predicate_atom.
IDLV2ParserVisitor.VisitOutput
Result VisitOutput([NotNull] DLV2Parser.OutputContext context)
Visit a parse tree produced by DLV2Parser.output.
IDLV2ParserVisitor.VisitModel
Result VisitModel([NotNull] DLV2Parser.ModelContext context)
Visit a parse tree produced by DLV2Parser.model.
IDLV2ParserVisitor.VisitAnswer_set
Result VisitAnswer_set([NotNull] DLV2Parser.Answer_setContext context)
Visit a parse tree produced by DLV2Parser.answer_set.
IDLV2ParserVisitor.VisitTerm
Result VisitTerm([NotNull] DLV2Parser.TermContext context)
Visit a parse tree produced by DLV2Parser.term.
IDLV2ParserVisitor.VisitLevel
Result VisitLevel([NotNull] DLV2Parser.LevelContext context)
Visit a parse tree produced by DLV2Parser.level.
IDLV2ParserVisitor.VisitCost
Result VisitCost([NotNull] DLV2Parser.CostContext context)
Visit a parse tree produced by DLV2Parser.cost.