Coverage for src/pyensae/languages/DOTParser.py: 0%

1# Generated from \DOT.g4 by ANTLR 4.10.1

2# encoding: utf-8

3from antlr4 import *

4from io import StringIO

5import sys

6if sys.version_info[1] > 5:

7 from typing import TextIO

8else:

9 from typing.io import TextIO

12def serializedATN():

13 return [

14 4, 1, 24, 129, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7,

15 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13,

16 1, 0, 3, 0, 30, 8, 0, 1, 0, 1, 0, 3, 0, 34, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3,

17 1, 43, 8, 1, 5, 1, 45, 8, 1, 10, 1, 12, 1, 48, 9, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2,

18 1, 2, 3, 2, 58, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 3, 4, 65, 8, 4, 1, 4, 4, 4, 68, 8, 4, 11,

19 4, 12, 4, 69, 1, 5, 1, 5, 1, 5, 3, 5, 75, 8, 5, 1, 5, 3, 5, 78, 8, 5, 4, 5, 80, 8, 5, 11, 5,

20 12, 5, 81, 1, 6, 1, 6, 3, 6, 86, 8, 6, 1, 6, 1, 6, 3, 6, 90, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7, 95,

21 8, 7, 4, 7, 97, 8, 7, 11, 7, 12, 7, 98, 1, 8, 1, 8, 1, 9, 1, 9, 3, 9, 105, 8, 9, 1, 10, 1, 10,

22 3, 10, 109, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 115, 8, 11, 1, 12, 1, 12, 3, 12, 119,

23 8, 12, 3, 12, 121, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 0, 0, 14, 0, 2,

24 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 0, 4, 1, 0, 12, 13, 2, 0, 12, 12, 14, 15, 1,

25 0, 8, 9, 1, 0, 17, 20, 136, 0, 29, 1, 0, 0, 0, 2, 46, 1, 0, 0, 0, 4, 57, 1, 0, 0, 0, 6, 59,

26 1, 0, 0, 0, 8, 67, 1, 0, 0, 0, 10, 79, 1, 0, 0, 0, 12, 85, 1, 0, 0, 0, 14, 96, 1, 0, 0, 0, 16,

27 100, 1, 0, 0, 0, 18, 102, 1, 0, 0, 0, 20, 106, 1, 0, 0, 0, 22, 110, 1, 0, 0, 0, 24, 120,

28 1, 0, 0, 0, 26, 126, 1, 0, 0, 0, 28, 30, 5, 11, 0, 0, 29, 28, 1, 0, 0, 0, 29, 30, 1, 0, 0,

29 0, 30, 31, 1, 0, 0, 0, 31, 33, 7, 0, 0, 0, 32, 34, 3, 26, 13, 0, 33, 32, 1, 0, 0, 0, 33, 34,

30 1, 0, 0, 0, 34, 35, 1, 0, 0, 0, 35, 36, 5, 1, 0, 0, 36, 37, 3, 2, 1, 0, 37, 38, 5, 2, 0, 0,

31 38, 39, 5, 0, 0, 1, 39, 1, 1, 0, 0, 0, 40, 42, 3, 4, 2, 0, 41, 43, 5, 3, 0, 0, 42, 41, 1, 0,

32 0, 0, 42, 43, 1, 0, 0, 0, 43, 45, 1, 0, 0, 0, 44, 40, 1, 0, 0, 0, 45, 48, 1, 0, 0, 0, 46, 44,

33 1, 0, 0, 0, 46, 47, 1, 0, 0, 0, 47, 3, 1, 0, 0, 0, 48, 46, 1, 0, 0, 0, 49, 58, 3, 18, 9, 0,

34 50, 58, 3, 12, 6, 0, 51, 58, 3, 6, 3, 0, 52, 53, 3, 26, 13, 0, 53, 54, 5, 4, 0, 0, 54, 55,

35 3, 26, 13, 0, 55, 58, 1, 0, 0, 0, 56, 58, 3, 24, 12, 0, 57, 49, 1, 0, 0, 0, 57, 50, 1, 0,

36 0, 0, 57, 51, 1, 0, 0, 0, 57, 52, 1, 0, 0, 0, 57, 56, 1, 0, 0, 0, 58, 5, 1, 0, 0, 0, 59, 60,

37 7, 1, 0, 0, 60, 61, 3, 8, 4, 0, 61, 7, 1, 0, 0, 0, 62, 64, 5, 5, 0, 0, 63, 65, 3, 10, 5, 0,

38 64, 63, 1, 0, 0, 0, 64, 65, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 68, 5, 6, 0, 0, 67, 62, 1,

39 0, 0, 0, 68, 69, 1, 0, 0, 0, 69, 67, 1, 0, 0, 0, 69, 70, 1, 0, 0, 0, 70, 9, 1, 0, 0, 0, 71,

40 74, 3, 26, 13, 0, 72, 73, 5, 4, 0, 0, 73, 75, 3, 26, 13, 0, 74, 72, 1, 0, 0, 0, 74, 75, 1,

41 0, 0, 0, 75, 77, 1, 0, 0, 0, 76, 78, 5, 7, 0, 0, 77, 76, 1, 0, 0, 0, 77, 78, 1, 0, 0, 0, 78,

42 80, 1, 0, 0, 0, 79, 71, 1, 0, 0, 0, 80, 81, 1, 0, 0, 0, 81, 79, 1, 0, 0, 0, 81, 82, 1, 0, 0,

43 0, 82, 11, 1, 0, 0, 0, 83, 86, 3, 20, 10, 0, 84, 86, 3, 24, 12, 0, 85, 83, 1, 0, 0, 0, 85,

44 84, 1, 0, 0, 0, 86, 87, 1, 0, 0, 0, 87, 89, 3, 14, 7, 0, 88, 90, 3, 8, 4, 0, 89, 88, 1, 0,

45 0, 0, 89, 90, 1, 0, 0, 0, 90, 13, 1, 0, 0, 0, 91, 94, 3, 16, 8, 0, 92, 95, 3, 20, 10, 0, 93,

46 95, 3, 24, 12, 0, 94, 92, 1, 0, 0, 0, 94, 93, 1, 0, 0, 0, 95, 97, 1, 0, 0, 0, 96, 91, 1, 0,

47 0, 0, 97, 98, 1, 0, 0, 0, 98, 96, 1, 0, 0, 0, 98, 99, 1, 0, 0, 0, 99, 15, 1, 0, 0, 0, 100,

48 101, 7, 2, 0, 0, 101, 17, 1, 0, 0, 0, 102, 104, 3, 20, 10, 0, 103, 105, 3, 8, 4, 0, 104,

49 103, 1, 0, 0, 0, 104, 105, 1, 0, 0, 0, 105, 19, 1, 0, 0, 0, 106, 108, 3, 26, 13, 0, 107,

50 109, 3, 22, 11, 0, 108, 107, 1, 0, 0, 0, 108, 109, 1, 0, 0, 0, 109, 21, 1, 0, 0, 0, 110,

51 111, 5, 10, 0, 0, 111, 114, 3, 26, 13, 0, 112, 113, 5, 10, 0, 0, 113, 115, 3, 26, 13,

52 0, 114, 112, 1, 0, 0, 0, 114, 115, 1, 0, 0, 0, 115, 23, 1, 0, 0, 0, 116, 118, 5, 16, 0,

53 0, 117, 119, 3, 26, 13, 0, 118, 117, 1, 0, 0, 0, 118, 119, 1, 0, 0, 0, 119, 121, 1, 0,

54 0, 0, 120, 116, 1, 0, 0, 0, 120, 121, 1, 0, 0, 0, 121, 122, 1, 0, 0, 0, 122, 123, 5, 1,

55 0, 0, 123, 124, 3, 2, 1, 0, 124, 125, 5, 2, 0, 0, 125, 25, 1, 0, 0, 0, 126, 127, 7, 3, 0,

56 0, 127, 27, 1, 0, 0, 0, 19, 29, 33, 42, 46, 57, 64, 69, 74, 77, 81, 85, 89, 94, 98, 104,

57 108, 114, 118, 120

58 ]

61class DOTParser (Parser):

63 grammarFileName = "DOT.g4"

65 atn = ATNDeserializer().deserialize(serializedATN())

67 decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]

69 sharedContextCache = PredictionContextCache()

71 literalNames = ["<INVALID>", "'{'", "'}'", "';'", "'='", "'['", "']'",

72 "','", "'->'", "'--'", "':'"]

74 symbolicNames = ["<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

75 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

76 "<INVALID>", "<INVALID>", "<INVALID>", "STRICT", "GRAPH",

77 "DIGRAPH", "NODE", "EDGE", "SUBGRAPH", "NUMBER", "STRING",

78 "ID", "HTML_STRING", "COMMENT", "LINE_COMMENT", "PREPROC",

79 "WS"]

81 RULE_graph = 0

82 RULE_stmt_list = 1

83 RULE_stmt = 2

84 RULE_attr_stmt = 3

85 RULE_attr_list = 4

86 RULE_a_list = 5

87 RULE_edge_stmt = 6

88 RULE_edgeRHS = 7

89 RULE_edgeop = 8

90 RULE_node_stmt = 9

91 RULE_node_id = 10

92 RULE_port = 11

93 RULE_subgraph = 12

94 RULE_id_ = 13

96 ruleNames = ["graph", "stmt_list", "stmt", "attr_stmt", "attr_list",

97 "a_list", "edge_stmt", "edgeRHS", "edgeop", "node_stmt",

98 "node_id", "port", "subgraph", "id_"]

100 EOF = Token.EOF

101 T__0 = 1

102 T__1 = 2

103 T__2 = 3

104 T__3 = 4

105 T__4 = 5

106 T__5 = 6

107 T__6 = 7

108 T__7 = 8

109 T__8 = 9

110 T__9 = 10

111 STRICT = 11

112 GRAPH = 12

113 DIGRAPH = 13

114 NODE = 14

115 EDGE = 15

116 SUBGRAPH = 16

117 NUMBER = 17

118 STRING = 18

119 ID = 19

120 HTML_STRING = 20

121 COMMENT = 21

122 LINE_COMMENT = 22

123 PREPROC = 23

124 WS = 24

125

126 def __init__(self, input: TokenStream, output: TextIO = sys.stdout):

127 super().__init__(input, output)

128 self.checkVersion("4.10.1")

129 self._interp = ParserATNSimulator(

130 self, self.atn, self.decisionsToDFA, self.sharedContextCache)

131 self._predicates = None

132

133 class GraphContext(ParserRuleContext):

134 __slots__ = 'parser'

135

136 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

137 super().__init__(parent, invokingState)

138 self.parser = parser

139

140 def stmt_list(self):

141 return self.getTypedRuleContext(DOTParser.Stmt_listContext, 0)

142

143 def EOF(self):

144 return self.getToken(DOTParser.EOF, 0)

145

146 def GRAPH(self):

147 return self.getToken(DOTParser.GRAPH, 0)

148

149 def DIGRAPH(self):

150 return self.getToken(DOTParser.DIGRAPH, 0)

151

152 def STRICT(self):

153 return self.getToken(DOTParser.STRICT, 0)

154

155 def id_(self):

156 return self.getTypedRuleContext(DOTParser.Id_Context, 0)

157

158 def getRuleIndex(self):

159 return DOTParser.RULE_graph

160

161 def enterRule(self, listener: ParseTreeListener):

162 if hasattr(listener, "enterGraph"):

163 listener.enterGraph(self)

164

165 def exitRule(self, listener: ParseTreeListener):

166 if hasattr(listener, "exitGraph"):

167 listener.exitGraph(self)

168

169 def graph(self):

170

171 localctx = DOTParser.GraphContext(self, self._ctx, self.state)

172 self.enterRule(localctx, 0, self.RULE_graph)

173 self._la = 0 # Token type

174 try:

175 self.enterOuterAlt(localctx, 1)

176 self.state = 29

177 self._errHandler.sync(self)

178 _la = self._input.LA(1)

179 if _la == DOTParser.STRICT:

180 self.state = 28

181 self.match(DOTParser.STRICT)

182

183 self.state = 31

184 _la = self._input.LA(1)

185 if not (_la == DOTParser.GRAPH or _la == DOTParser.DIGRAPH):

186 self._errHandler.recoverInline(self)

187 else:

188 self._errHandler.reportMatch(self)

189 self.consume()

190 self.state = 33

191 self._errHandler.sync(self)

192 _la = self._input.LA(1)

193 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.NUMBER) | (1 << DOTParser.STRING) | (1 << DOTParser.ID) | (1 << DOTParser.HTML_STRING))) != 0):

194 self.state = 32

195 self.id_()

196

197 self.state = 35

198 self.match(DOTParser.T__0)

199 self.state = 36

200 self.stmt_list()

201 self.state = 37

202 self.match(DOTParser.T__1)

203 self.state = 38

204 self.match(DOTParser.EOF)

205 except RecognitionException as re:

206 localctx.exception = re

207 self._errHandler.reportError(self, re)

208 self._errHandler.recover(self, re)

209 finally:

210 self.exitRule()

211 return localctx

212

213 class Stmt_listContext(ParserRuleContext):

214 __slots__ = 'parser'

215

216 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

217 super().__init__(parent, invokingState)

218 self.parser = parser

219

220 def stmt(self, i: int = None):

221 if i is None:

222 return self.getTypedRuleContexts(DOTParser.StmtContext)

223 else:

224 return self.getTypedRuleContext(DOTParser.StmtContext, i)

225

226 def getRuleIndex(self):

227 return DOTParser.RULE_stmt_list

228

229 def enterRule(self, listener: ParseTreeListener):

230 if hasattr(listener, "enterStmt_list"):

231 listener.enterStmt_list(self)

232

233 def exitRule(self, listener: ParseTreeListener):

234 if hasattr(listener, "exitStmt_list"):

235 listener.exitStmt_list(self)

236

237 def stmt_list(self):

238

239 localctx = DOTParser.Stmt_listContext(self, self._ctx, self.state)

240 self.enterRule(localctx, 2, self.RULE_stmt_list)

241 self._la = 0 # Token type

242 try:

243 self.enterOuterAlt(localctx, 1)

244 self.state = 46

245 self._errHandler.sync(self)

246 _la = self._input.LA(1)

248 self.state = 40

249 self.stmt()

250 self.state = 42

251 self._errHandler.sync(self)

252 _la = self._input.LA(1)

253 if _la == DOTParser.T__2:

254 self.state = 41

255 self.match(DOTParser.T__2)

256

257 self.state = 48

258 self._errHandler.sync(self)

259 _la = self._input.LA(1)

260

261 except RecognitionException as re:

262 localctx.exception = re

263 self._errHandler.reportError(self, re)

264 self._errHandler.recover(self, re)

265 finally:

266 self.exitRule()

267 return localctx

268

269 class StmtContext(ParserRuleContext):

270 __slots__ = 'parser'

271

272 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

273 super().__init__(parent, invokingState)

274 self.parser = parser

275

276 def node_stmt(self):

277 return self.getTypedRuleContext(DOTParser.Node_stmtContext, 0)

278

279 def edge_stmt(self):

280 return self.getTypedRuleContext(DOTParser.Edge_stmtContext, 0)

281

282 def attr_stmt(self):

283 return self.getTypedRuleContext(DOTParser.Attr_stmtContext, 0)

284

285 def id_(self, i: int = None):

286 if i is None:

287 return self.getTypedRuleContexts(DOTParser.Id_Context)

288 else:

289 return self.getTypedRuleContext(DOTParser.Id_Context, i)

290

291 def subgraph(self):

292 return self.getTypedRuleContext(DOTParser.SubgraphContext, 0)

293

294 def getRuleIndex(self):

295 return DOTParser.RULE_stmt

296

297 def enterRule(self, listener: ParseTreeListener):

298 if hasattr(listener, "enterStmt"):

299 listener.enterStmt(self)

300

301 def exitRule(self, listener: ParseTreeListener):

302 if hasattr(listener, "exitStmt"):

303 listener.exitStmt(self)

304

305 def stmt(self):

306

307 localctx = DOTParser.StmtContext(self, self._ctx, self.state)

308 self.enterRule(localctx, 4, self.RULE_stmt)

309 try:

310 self.state = 57

311 self._errHandler.sync(self)

312 la_ = self._interp.adaptivePredict(self._input, 4, self._ctx)

313 if la_ == 1:

314 self.enterOuterAlt(localctx, 1)

315 self.state = 49

316 self.node_stmt()

317 pass

318

319 elif la_ == 2:

320 self.enterOuterAlt(localctx, 2)

321 self.state = 50

322 self.edge_stmt()

323 pass

324

325 elif la_ == 3:

326 self.enterOuterAlt(localctx, 3)

327 self.state = 51

328 self.attr_stmt()

329 pass

330

331 elif la_ == 4:

332 self.enterOuterAlt(localctx, 4)

333 self.state = 52

334 self.id_()

335 self.state = 53

336 self.match(DOTParser.T__3)

337 self.state = 54

338 self.id_()

339 pass

340

341 elif la_ == 5:

342 self.enterOuterAlt(localctx, 5)

343 self.state = 56

344 self.subgraph()

345 pass

346

347 except RecognitionException as re:

348 localctx.exception = re

349 self._errHandler.reportError(self, re)

350 self._errHandler.recover(self, re)

351 finally:

352 self.exitRule()

353 return localctx

354

355 class Attr_stmtContext(ParserRuleContext):

356 __slots__ = 'parser'

357

358 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

359 super().__init__(parent, invokingState)

360 self.parser = parser

361

362 def attr_list(self):

363 return self.getTypedRuleContext(DOTParser.Attr_listContext, 0)

364

365 def GRAPH(self):

366 return self.getToken(DOTParser.GRAPH, 0)

367

368 def NODE(self):

369 return self.getToken(DOTParser.NODE, 0)

370

371 def EDGE(self):

372 return self.getToken(DOTParser.EDGE, 0)

373

374 def getRuleIndex(self):

375 return DOTParser.RULE_attr_stmt

376

377 def enterRule(self, listener: ParseTreeListener):

378 if hasattr(listener, "enterAttr_stmt"):

379 listener.enterAttr_stmt(self)

380

381 def exitRule(self, listener: ParseTreeListener):

382 if hasattr(listener, "exitAttr_stmt"):

383 listener.exitAttr_stmt(self)

384

385 def attr_stmt(self):

386

387 localctx = DOTParser.Attr_stmtContext(self, self._ctx, self.state)

388 self.enterRule(localctx, 6, self.RULE_attr_stmt)

389 self._la = 0 # Token type

390 try:

391 self.enterOuterAlt(localctx, 1)

392 self.state = 59

393 _la = self._input.LA(1)

394 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.GRAPH) | (1 << DOTParser.NODE) | (1 << DOTParser.EDGE))) != 0)):

395 self._errHandler.recoverInline(self)

396 else:

397 self._errHandler.reportMatch(self)

398 self.consume()

399 self.state = 60

400 self.attr_list()

401 except RecognitionException as re:

402 localctx.exception = re

403 self._errHandler.reportError(self, re)

404 self._errHandler.recover(self, re)

405 finally:

406 self.exitRule()

407 return localctx

408

409 class Attr_listContext(ParserRuleContext):

410 __slots__ = 'parser'

411

412 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

413 super().__init__(parent, invokingState)

414 self.parser = parser

415

416 def a_list(self, i: int = None):

417 if i is None:

418 return self.getTypedRuleContexts(DOTParser.A_listContext)

419 else:

420 return self.getTypedRuleContext(DOTParser.A_listContext, i)

421

422 def getRuleIndex(self):

423 return DOTParser.RULE_attr_list

424

425 def enterRule(self, listener: ParseTreeListener):

426 if hasattr(listener, "enterAttr_list"):

427 listener.enterAttr_list(self)

428

429 def exitRule(self, listener: ParseTreeListener):

430 if hasattr(listener, "exitAttr_list"):

431 listener.exitAttr_list(self)

432

433 def attr_list(self):

434

435 localctx = DOTParser.Attr_listContext(self, self._ctx, self.state)

436 self.enterRule(localctx, 8, self.RULE_attr_list)

437 self._la = 0 # Token type

438 try:

439 self.enterOuterAlt(localctx, 1)

440 self.state = 67

441 self._errHandler.sync(self)

442 _la = self._input.LA(1)

443 while True:

444 self.state = 62

445 self.match(DOTParser.T__4)

446 self.state = 64

447 self._errHandler.sync(self)

448 _la = self._input.LA(1)

449 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.NUMBER) | (1 << DOTParser.STRING) | (1 << DOTParser.ID) | (1 << DOTParser.HTML_STRING))) != 0):

450 self.state = 63

451 self.a_list()

452

453 self.state = 66

454 self.match(DOTParser.T__5)

455 self.state = 69

456 self._errHandler.sync(self)

457 _la = self._input.LA(1)

458 if not (_la == DOTParser.T__4):

459 break

460

461 except RecognitionException as re:

462 localctx.exception = re

463 self._errHandler.reportError(self, re)

464 self._errHandler.recover(self, re)

465 finally:

466 self.exitRule()

467 return localctx

468

469 class A_listContext(ParserRuleContext):

470 __slots__ = 'parser'

471

472 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

473 super().__init__(parent, invokingState)

474 self.parser = parser

475

476 def id_(self, i: int = None):

477 if i is None:

478 return self.getTypedRuleContexts(DOTParser.Id_Context)

479 else:

480 return self.getTypedRuleContext(DOTParser.Id_Context, i)

481

482 def getRuleIndex(self):

483 return DOTParser.RULE_a_list

484

485 def enterRule(self, listener: ParseTreeListener):

486 if hasattr(listener, "enterA_list"):

487 listener.enterA_list(self)

488

489 def exitRule(self, listener: ParseTreeListener):

490 if hasattr(listener, "exitA_list"):

491 listener.exitA_list(self)

492

493 def a_list(self):

494

495 localctx = DOTParser.A_listContext(self, self._ctx, self.state)

496 self.enterRule(localctx, 10, self.RULE_a_list)

497 self._la = 0 # Token type

498 try:

499 self.enterOuterAlt(localctx, 1)

500 self.state = 79

501 self._errHandler.sync(self)

502 _la = self._input.LA(1)

503 while True:

504 self.state = 71

505 self.id_()

506 self.state = 74

507 self._errHandler.sync(self)

508 _la = self._input.LA(1)

509 if _la == DOTParser.T__3:

510 self.state = 72

511 self.match(DOTParser.T__3)

512 self.state = 73

513 self.id_()

514

515 self.state = 77

516 self._errHandler.sync(self)

517 _la = self._input.LA(1)

518 if _la == DOTParser.T__6:

519 self.state = 76

520 self.match(DOTParser.T__6)

521

522 self.state = 81

523 self._errHandler.sync(self)

524 _la = self._input.LA(1)

525 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.NUMBER) | (1 << DOTParser.STRING) | (1 << DOTParser.ID) | (1 << DOTParser.HTML_STRING))) != 0)):

526 break

527

528 except RecognitionException as re:

529 localctx.exception = re

530 self._errHandler.reportError(self, re)

531 self._errHandler.recover(self, re)

532 finally:

533 self.exitRule()

534 return localctx

535

536 class Edge_stmtContext(ParserRuleContext):

537 __slots__ = 'parser'

538

539 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

540 super().__init__(parent, invokingState)

541 self.parser = parser

542

543 def edgeRHS(self):

544 return self.getTypedRuleContext(DOTParser.EdgeRHSContext, 0)

545

546 def node_id(self):

547 return self.getTypedRuleContext(DOTParser.Node_idContext, 0)

548

549 def subgraph(self):

550 return self.getTypedRuleContext(DOTParser.SubgraphContext, 0)

551

552 def attr_list(self):

553 return self.getTypedRuleContext(DOTParser.Attr_listContext, 0)

554

555 def getRuleIndex(self):

556 return DOTParser.RULE_edge_stmt

557

558 def enterRule(self, listener: ParseTreeListener):

559 if hasattr(listener, "enterEdge_stmt"):

560 listener.enterEdge_stmt(self)

561

562 def exitRule(self, listener: ParseTreeListener):

563 if hasattr(listener, "exitEdge_stmt"):

564 listener.exitEdge_stmt(self)

565

566 def edge_stmt(self):

567

568 localctx = DOTParser.Edge_stmtContext(self, self._ctx, self.state)

569 self.enterRule(localctx, 12, self.RULE_edge_stmt)

570 self._la = 0 # Token type

571 try:

572 self.enterOuterAlt(localctx, 1)

573 self.state = 85

574 self._errHandler.sync(self)

575 token = self._input.LA(1)

576 if token in [DOTParser.NUMBER, DOTParser.STRING, DOTParser.ID, DOTParser.HTML_STRING]:

577 self.state = 83

578 self.node_id()

579 pass

580 elif token in [DOTParser.T__0, DOTParser.SUBGRAPH]:

581 self.state = 84

582 self.subgraph()

583 pass

584 else:

585 raise NoViableAltException(self)

586

587 self.state = 87

588 self.edgeRHS()

589 self.state = 89

590 self._errHandler.sync(self)

591 _la = self._input.LA(1)

592 if _la == DOTParser.T__4:

593 self.state = 88

594 self.attr_list()

595

596 except RecognitionException as re:

597 localctx.exception = re

598 self._errHandler.reportError(self, re)

599 self._errHandler.recover(self, re)

600 finally:

601 self.exitRule()

602 return localctx

603

604 class EdgeRHSContext(ParserRuleContext):

605 __slots__ = 'parser'

606

607 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

608 super().__init__(parent, invokingState)

609 self.parser = parser

610

611 def edgeop(self, i: int = None):

612 if i is None:

613 return self.getTypedRuleContexts(DOTParser.EdgeopContext)

614 else:

615 return self.getTypedRuleContext(DOTParser.EdgeopContext, i)

616

617 def node_id(self, i: int = None):

618 if i is None:

619 return self.getTypedRuleContexts(DOTParser.Node_idContext)

620 else:

621 return self.getTypedRuleContext(DOTParser.Node_idContext, i)

622

623 def subgraph(self, i: int = None):

624 if i is None:

625 return self.getTypedRuleContexts(DOTParser.SubgraphContext)

626 else:

627 return self.getTypedRuleContext(DOTParser.SubgraphContext, i)

628

629 def getRuleIndex(self):

630 return DOTParser.RULE_edgeRHS

631

632 def enterRule(self, listener: ParseTreeListener):

633 if hasattr(listener, "enterEdgeRHS"):

634 listener.enterEdgeRHS(self)

635

636 def exitRule(self, listener: ParseTreeListener):

637 if hasattr(listener, "exitEdgeRHS"):

638 listener.exitEdgeRHS(self)

639

640 def edgeRHS(self):

641

642 localctx = DOTParser.EdgeRHSContext(self, self._ctx, self.state)

643 self.enterRule(localctx, 14, self.RULE_edgeRHS)

644 self._la = 0 # Token type

645 try:

646 self.enterOuterAlt(localctx, 1)

647 self.state = 96

648 self._errHandler.sync(self)

649 _la = self._input.LA(1)

650 while True:

651 self.state = 91

652 self.edgeop()

653 self.state = 94

654 self._errHandler.sync(self)

655 token = self._input.LA(1)

656 if token in [DOTParser.NUMBER, DOTParser.STRING, DOTParser.ID, DOTParser.HTML_STRING]:

657 self.state = 92

658 self.node_id()

659 pass

660 elif token in [DOTParser.T__0, DOTParser.SUBGRAPH]:

661 self.state = 93

662 self.subgraph()

663 pass

664 else:

665 raise NoViableAltException(self)

666

667 self.state = 98

668 self._errHandler.sync(self)

669 _la = self._input.LA(1)

670 if not (_la == DOTParser.T__7 or _la == DOTParser.T__8):

671 break

672

673 except RecognitionException as re:

674 localctx.exception = re

675 self._errHandler.reportError(self, re)

676 self._errHandler.recover(self, re)

677 finally:

678 self.exitRule()

679 return localctx

680

681 class EdgeopContext(ParserRuleContext):

682 __slots__ = 'parser'

683

684 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

685 super().__init__(parent, invokingState)

686 self.parser = parser

687

688 def getRuleIndex(self):

689 return DOTParser.RULE_edgeop

690

691 def enterRule(self, listener: ParseTreeListener):

692 if hasattr(listener, "enterEdgeop"):

693 listener.enterEdgeop(self)

694

695 def exitRule(self, listener: ParseTreeListener):

696 if hasattr(listener, "exitEdgeop"):

697 listener.exitEdgeop(self)

698

699 def edgeop(self):

700

701 localctx = DOTParser.EdgeopContext(self, self._ctx, self.state)

702 self.enterRule(localctx, 16, self.RULE_edgeop)

703 self._la = 0 # Token type

704 try:

705 self.enterOuterAlt(localctx, 1)

706 self.state = 100

707 _la = self._input.LA(1)

708 if not (_la == DOTParser.T__7 or _la == DOTParser.T__8):

709 self._errHandler.recoverInline(self)

710 else:

711 self._errHandler.reportMatch(self)

712 self.consume()

713 except RecognitionException as re:

714 localctx.exception = re

715 self._errHandler.reportError(self, re)

716 self._errHandler.recover(self, re)

717 finally:

718 self.exitRule()

719 return localctx

720

721 class Node_stmtContext(ParserRuleContext):

722 __slots__ = 'parser'

723

724 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

725 super().__init__(parent, invokingState)

726 self.parser = parser

727

728 def node_id(self):

729 return self.getTypedRuleContext(DOTParser.Node_idContext, 0)

730

731 def attr_list(self):

732 return self.getTypedRuleContext(DOTParser.Attr_listContext, 0)

733

734 def getRuleIndex(self):

735 return DOTParser.RULE_node_stmt

736

737 def enterRule(self, listener: ParseTreeListener):

738 if hasattr(listener, "enterNode_stmt"):

739 listener.enterNode_stmt(self)

740

741 def exitRule(self, listener: ParseTreeListener):

742 if hasattr(listener, "exitNode_stmt"):

743 listener.exitNode_stmt(self)

744

745 def node_stmt(self):

746

747 localctx = DOTParser.Node_stmtContext(self, self._ctx, self.state)

748 self.enterRule(localctx, 18, self.RULE_node_stmt)

749 self._la = 0 # Token type

750 try:

751 self.enterOuterAlt(localctx, 1)

752 self.state = 102

753 self.node_id()

754 self.state = 104

755 self._errHandler.sync(self)

756 _la = self._input.LA(1)

757 if _la == DOTParser.T__4:

758 self.state = 103

759 self.attr_list()

760

761 except RecognitionException as re:

762 localctx.exception = re

763 self._errHandler.reportError(self, re)

764 self._errHandler.recover(self, re)

765 finally:

766 self.exitRule()

767 return localctx

768

769 class Node_idContext(ParserRuleContext):

770 __slots__ = 'parser'

771

772 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

773 super().__init__(parent, invokingState)

774 self.parser = parser

775

776 def id_(self):

777 return self.getTypedRuleContext(DOTParser.Id_Context, 0)

778

779 def port(self):

780 return self.getTypedRuleContext(DOTParser.PortContext, 0)

781

782 def getRuleIndex(self):

783 return DOTParser.RULE_node_id

784

785 def enterRule(self, listener: ParseTreeListener):

786 if hasattr(listener, "enterNode_id"):

787 listener.enterNode_id(self)

788

789 def exitRule(self, listener: ParseTreeListener):

790 if hasattr(listener, "exitNode_id"):

791 listener.exitNode_id(self)

792

793 def node_id(self):

794

795 localctx = DOTParser.Node_idContext(self, self._ctx, self.state)

796 self.enterRule(localctx, 20, self.RULE_node_id)

797 self._la = 0 # Token type

798 try:

799 self.enterOuterAlt(localctx, 1)

800 self.state = 106

801 self.id_()

802 self.state = 108

803 self._errHandler.sync(self)

804 _la = self._input.LA(1)

805 if _la == DOTParser.T__9:

806 self.state = 107

807 self.port()

808

809 except RecognitionException as re:

810 localctx.exception = re

811 self._errHandler.reportError(self, re)

812 self._errHandler.recover(self, re)

813 finally:

814 self.exitRule()

815 return localctx

816

817 class PortContext(ParserRuleContext):

818 __slots__ = 'parser'

819

820 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

821 super().__init__(parent, invokingState)

822 self.parser = parser

823

824 def id_(self, i: int = None):

825 if i is None:

826 return self.getTypedRuleContexts(DOTParser.Id_Context)

827 else:

828 return self.getTypedRuleContext(DOTParser.Id_Context, i)

829

830 def getRuleIndex(self):

831 return DOTParser.RULE_port

832

833 def enterRule(self, listener: ParseTreeListener):

834 if hasattr(listener, "enterPort"):

835 listener.enterPort(self)

836

837 def exitRule(self, listener: ParseTreeListener):

838 if hasattr(listener, "exitPort"):

839 listener.exitPort(self)

840

841 def port(self):

842

843 localctx = DOTParser.PortContext(self, self._ctx, self.state)

844 self.enterRule(localctx, 22, self.RULE_port)

845 self._la = 0 # Token type

846 try:

847 self.enterOuterAlt(localctx, 1)

848 self.state = 110

849 self.match(DOTParser.T__9)

850 self.state = 111

851 self.id_()

852 self.state = 114

853 self._errHandler.sync(self)

854 _la = self._input.LA(1)

855 if _la == DOTParser.T__9:

856 self.state = 112

857 self.match(DOTParser.T__9)

858 self.state = 113

859 self.id_()

860

861 except RecognitionException as re:

862 localctx.exception = re

863 self._errHandler.reportError(self, re)

864 self._errHandler.recover(self, re)

865 finally:

866 self.exitRule()

867 return localctx

868

869 class SubgraphContext(ParserRuleContext):

870 __slots__ = 'parser'

871

872 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

873 super().__init__(parent, invokingState)

874 self.parser = parser

875

876 def stmt_list(self):

877 return self.getTypedRuleContext(DOTParser.Stmt_listContext, 0)

878

879 def SUBGRAPH(self):

880 return self.getToken(DOTParser.SUBGRAPH, 0)

881

882 def id_(self):

883 return self.getTypedRuleContext(DOTParser.Id_Context, 0)

884

885 def getRuleIndex(self):

886 return DOTParser.RULE_subgraph

887

888 def enterRule(self, listener: ParseTreeListener):

889 if hasattr(listener, "enterSubgraph"):

890 listener.enterSubgraph(self)

891

892 def exitRule(self, listener: ParseTreeListener):

893 if hasattr(listener, "exitSubgraph"):

894 listener.exitSubgraph(self)

895

896 def subgraph(self):

897

898 localctx = DOTParser.SubgraphContext(self, self._ctx, self.state)

899 self.enterRule(localctx, 24, self.RULE_subgraph)

900 self._la = 0 # Token type

901 try:

902 self.enterOuterAlt(localctx, 1)

903 self.state = 120

904 self._errHandler.sync(self)

905 _la = self._input.LA(1)

906 if _la == DOTParser.SUBGRAPH:

907 self.state = 116

908 self.match(DOTParser.SUBGRAPH)

909 self.state = 118

910 self._errHandler.sync(self)

911 _la = self._input.LA(1)

912 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.NUMBER) | (1 << DOTParser.STRING) | (1 << DOTParser.ID) | (1 << DOTParser.HTML_STRING))) != 0):

913 self.state = 117

914 self.id_()

915

916 self.state = 122

917 self.match(DOTParser.T__0)

918 self.state = 123

919 self.stmt_list()

920 self.state = 124

921 self.match(DOTParser.T__1)

922 except RecognitionException as re:

923 localctx.exception = re

924 self._errHandler.reportError(self, re)

925 self._errHandler.recover(self, re)

926 finally:

927 self.exitRule()

928 return localctx

929

930 class Id_Context(ParserRuleContext):

931 __slots__ = 'parser'

932

933 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):

934 super().__init__(parent, invokingState)

935 self.parser = parser

936

937 def ID(self):

938 return self.getToken(DOTParser.ID, 0)

939

940 def STRING(self):

941 return self.getToken(DOTParser.STRING, 0)

942

943 def HTML_STRING(self):

944 return self.getToken(DOTParser.HTML_STRING, 0)

945

946 def NUMBER(self):

947 return self.getToken(DOTParser.NUMBER, 0)

948

949 def getRuleIndex(self):

950 return DOTParser.RULE_id_

951

952 def enterRule(self, listener: ParseTreeListener):

953 if hasattr(listener, "enterId_"):

954 listener.enterId_(self)

955

956 def exitRule(self, listener: ParseTreeListener):

957 if hasattr(listener, "exitId_"):

958 listener.exitId_(self)

959

960 def id_(self):

961

962 localctx = DOTParser.Id_Context(self, self._ctx, self.state)

963 self.enterRule(localctx, 26, self.RULE_id_)

964 self._la = 0 # Token type

965 try:

966 self.enterOuterAlt(localctx, 1)

967 self.state = 126

968 _la = self._input.LA(1)

969 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.NUMBER) | (1 << DOTParser.STRING) | (1 << DOTParser.ID) | (1 << DOTParser.HTML_STRING))) != 0)):

970 self._errHandler.recoverInline(self)

971 else:

972 self._errHandler.reportMatch(self)

973 self.consume()

974 except RecognitionException as re:

975 localctx.exception = re

976 self._errHandler.reportError(self, re)

977 self._errHandler.recover(self, re)

978 finally:

979 self.exitRule()

980 return localctx