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