1# Generated from \DOT.g4 by ANTLR 4.9 

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 

10 

11 

12def serializedATN(): 

13 with StringIO() as buf: 

14 buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\35") 

15 buf.write("\u008a\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") 

16 buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") 

17 buf.write("\t\16\4\17\t\17\4\20\t\20\3\2\5\2\"\n\2\3\2\3\2\5\2&\n") 

18 buf.write("\2\3\2\3\2\3\2\3\2\3\3\3\3\5\3.\n\3\7\3\60\n\3\f\3\16") 

19 buf.write("\3\63\13\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4=\n\4\3") 

20 buf.write("\5\3\5\3\5\3\6\3\6\5\6D\n\6\3\6\6\6G\n\6\r\6\16\6H\3\7") 

21 buf.write("\3\7\3\7\5\7N\n\7\3\7\5\7Q\n\7\6\7S\n\7\r\7\16\7T\3\b") 

22 buf.write("\3\b\5\bY\n\b\3\b\3\b\5\b]\n\b\3\t\3\t\3\t\5\tb\n\t\6") 

23 buf.write("\td\n\t\r\t\16\te\3\n\3\n\3\13\3\13\5\13l\n\13\3\f\3\f") 

24 buf.write("\5\fp\n\f\3\r\3\r\3\r\3\r\5\rv\n\r\3\r\3\r\5\rz\n\r\3") 

25 buf.write("\16\3\16\5\16~\n\16\5\16\u0080\n\16\3\16\3\16\3\16\3\16") 

26 buf.write("\3\17\3\17\3\20\3\20\3\20\2\2\21\2\4\6\b\n\f\16\20\22") 

27 buf.write("\24\26\30\32\34\36\2\7\3\2\17\20\4\2\17\17\21\22\3\2\n") 

28 buf.write("\13\4\2\r\r\31\31\4\2\24\26\31\31\2\u0091\2!\3\2\2\2\4") 

29 buf.write("\61\3\2\2\2\6<\3\2\2\2\b>\3\2\2\2\nF\3\2\2\2\fR\3\2\2") 

30 buf.write("\2\16X\3\2\2\2\20c\3\2\2\2\22g\3\2\2\2\24i\3\2\2\2\26") 

31 buf.write("m\3\2\2\2\30y\3\2\2\2\32\177\3\2\2\2\34\u0085\3\2\2\2") 

32 buf.write("\36\u0087\3\2\2\2 \"\7\16\2\2! \3\2\2\2!\"\3\2\2\2\"#") 

33 buf.write("\3\2\2\2#%\t\2\2\2$&\5\36\20\2%$\3\2\2\2%&\3\2\2\2&\'") 

34 buf.write("\3\2\2\2\'(\7\3\2\2()\5\4\3\2)*\7\4\2\2*\3\3\2\2\2+-\5") 

35 buf.write("\6\4\2,.\7\5\2\2-,\3\2\2\2-.\3\2\2\2.\60\3\2\2\2/+\3\2") 

36 buf.write("\2\2\60\63\3\2\2\2\61/\3\2\2\2\61\62\3\2\2\2\62\5\3\2") 

37 buf.write("\2\2\63\61\3\2\2\2\64=\5\24\13\2\65=\5\16\b\2\66=\5\b") 

38 buf.write("\5\2\678\5\36\20\289\7\6\2\29:\5\36\20\2:=\3\2\2\2;=\5") 

39 buf.write("\32\16\2<\64\3\2\2\2<\65\3\2\2\2<\66\3\2\2\2<\67\3\2\2") 

40 buf.write("\2<;\3\2\2\2=\7\3\2\2\2>?\t\3\2\2?@\5\n\6\2@\t\3\2\2\2") 

41 buf.write("AC\7\7\2\2BD\5\f\7\2CB\3\2\2\2CD\3\2\2\2DE\3\2\2\2EG\7") 

42 buf.write("\b\2\2FA\3\2\2\2GH\3\2\2\2HF\3\2\2\2HI\3\2\2\2I\13\3\2") 

43 buf.write("\2\2JM\5\36\20\2KL\7\6\2\2LN\5\36\20\2MK\3\2\2\2MN\3\2") 

44 buf.write("\2\2NP\3\2\2\2OQ\7\t\2\2PO\3\2\2\2PQ\3\2\2\2QS\3\2\2\2") 

45 buf.write("RJ\3\2\2\2ST\3\2\2\2TR\3\2\2\2TU\3\2\2\2U\r\3\2\2\2VY") 

46 buf.write("\5\26\f\2WY\5\32\16\2XV\3\2\2\2XW\3\2\2\2YZ\3\2\2\2Z\\") 

47 buf.write("\5\20\t\2[]\5\n\6\2\\[\3\2\2\2\\]\3\2\2\2]\17\3\2\2\2") 

48 buf.write("^a\5\22\n\2_b\5\26\f\2`b\5\32\16\2a_\3\2\2\2a`\3\2\2\2") 

49 buf.write("bd\3\2\2\2c^\3\2\2\2de\3\2\2\2ec\3\2\2\2ef\3\2\2\2f\21") 

50 buf.write("\3\2\2\2gh\t\4\2\2h\23\3\2\2\2ik\5\26\f\2jl\5\n\6\2kj") 

51 buf.write("\3\2\2\2kl\3\2\2\2l\25\3\2\2\2mo\5\36\20\2np\5\30\r\2") 

52 buf.write("on\3\2\2\2op\3\2\2\2p\27\3\2\2\2qr\7\f\2\2ru\5\36\20\2") 

53 buf.write("st\7\f\2\2tv\5\34\17\2us\3\2\2\2uv\3\2\2\2vz\3\2\2\2w") 

54 buf.write("x\7\f\2\2xz\5\34\17\2yq\3\2\2\2yw\3\2\2\2z\31\3\2\2\2") 

55 buf.write("{}\7\23\2\2|~\5\36\20\2}|\3\2\2\2}~\3\2\2\2~\u0080\3\2") 

56 buf.write("\2\2\177{\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081\3\2\2") 

57 buf.write("\2\u0081\u0082\7\3\2\2\u0082\u0083\5\4\3\2\u0083\u0084") 

58 buf.write("\7\4\2\2\u0084\33\3\2\2\2\u0085\u0086\t\5\2\2\u0086\35") 

59 buf.write("\3\2\2\2\u0087\u0088\t\6\2\2\u0088\37\3\2\2\2\26!%-\61") 

60 buf.write("<CHMPTX\\aekouy}\177") 

61 return buf.getvalue() 

62 

63 

64class DOTParser (Parser): 

65 

66 grammarFileName = "DOT.g4" 

67 

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

69 

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

71 

72 sharedContextCache = PredictionContextCache() 

73 

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

75 "','", "'->'", "'--'", "':'", "'_'"] 

76 

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

78 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

79 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

80 "STRICT", "GRAPH", "DIGRAPH", "NODE", "EDGE", "SUBGRAPH", 

81 "NUMBER", "STRING", "HTML_STRING", "TAG", "EntityRef", 

82 "ID", "COMMENT", "LINE_COMMENT", "PREPROC", "WS"] 

83 

84 RULE_graph = 0 

85 RULE_stmt_list = 1 

86 RULE_stmt = 2 

87 RULE_attr_stmt = 3 

88 RULE_attr_list = 4 

89 RULE_a_list = 5 

90 RULE_edge_stmt = 6 

91 RULE_edgeRHS = 7 

92 RULE_edgeop = 8 

93 RULE_node_stmt = 9 

94 RULE_node_id = 10 

95 RULE_port = 11 

96 RULE_subgraph = 12 

97 RULE_compass_pt = 13 

98 RULE_gid = 14 

99 

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

101 "a_list", "edge_stmt", "edgeRHS", "edgeop", "node_stmt", 

102 "node_id", "port", "subgraph", "compass_pt", "gid"] 

103 

104 EOF = Token.EOF 

105 T__0 = 1 

106 T__1 = 2 

107 T__2 = 3 

108 T__3 = 4 

109 T__4 = 5 

110 T__5 = 6 

111 T__6 = 7 

112 T__7 = 8 

113 T__8 = 9 

114 T__9 = 10 

115 T__10 = 11 

116 STRICT = 12 

117 GRAPH = 13 

118 DIGRAPH = 14 

119 NODE = 15 

120 EDGE = 16 

121 SUBGRAPH = 17 

122 NUMBER = 18 

123 STRING = 19 

124 HTML_STRING = 20 

125 TAG = 21 

126 EntityRef = 22 

127 ID = 23 

128 COMMENT = 24 

129 LINE_COMMENT = 25 

130 PREPROC = 26 

131 WS = 27 

132 

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

134 super().__init__(input, output) 

135 self.checkVersion("4.9") 

136 self._interp = ParserATNSimulator( 

137 self, self.atn, self.decisionsToDFA, self.sharedContextCache) 

138 self._predicates = None 

139 

140 class GraphContext(ParserRuleContext): 

141 

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

143 super().__init__(parent, invokingState) 

144 self.parser = parser 

145 

146 def stmt_list(self): 

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

148 

149 def GRAPH(self): 

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

151 

152 def DIGRAPH(self): 

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

154 

155 def STRICT(self): 

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

157 

158 def gid(self): 

159 return self.getTypedRuleContext(DOTParser.GidContext, 0) 

160 

161 def getRuleIndex(self): 

162 return DOTParser.RULE_graph 

163 

164 def enterRule(self, listener: ParseTreeListener): 

165 if hasattr(listener, "enterGraph"): 

166 listener.enterGraph(self) 

167 

168 def exitRule(self, listener: ParseTreeListener): 

169 if hasattr(listener, "exitGraph"): 

170 listener.exitGraph(self) 

171 

172 def graph(self): 

173 

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

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

176 self._la = 0 # Token type 

177 try: 

178 self.enterOuterAlt(localctx, 1) 

179 self.state = 31 

180 self._errHandler.sync(self) 

181 _la = self._input.LA(1) 

182 if _la == DOTParser.STRICT: 

183 self.state = 30 

184 self.match(DOTParser.STRICT) 

185 

186 self.state = 33 

187 _la = self._input.LA(1) 

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

189 self._errHandler.recoverInline(self) 

190 else: 

191 self._errHandler.reportMatch(self) 

192 self.consume() 

193 self.state = 35 

194 self._errHandler.sync(self) 

195 _la = self._input.LA(1) 

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

197 self.state = 34 

198 self.gid() 

199 

200 self.state = 37 

201 self.match(DOTParser.T__0) 

202 self.state = 38 

203 self.stmt_list() 

204 self.state = 39 

205 self.match(DOTParser.T__1) 

206 except RecognitionException as re: 

207 localctx.exception = re 

208 self._errHandler.reportError(self, re) 

209 self._errHandler.recover(self, re) 

210 finally: 

211 self.exitRule() 

212 return localctx 

213 

214 class Stmt_listContext(ParserRuleContext): 

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 = 47 

245 self._errHandler.sync(self) 

246 _la = self._input.LA(1) 

247 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << DOTParser.T__0) | (1 << DOTParser.GRAPH) | (1 << DOTParser.NODE) | (1 << DOTParser.EDGE) | (1 << DOTParser.SUBGRAPH) | (1 << DOTParser.NUMBER) | (1 << DOTParser.STRING) | (1 << DOTParser.HTML_STRING) | (1 << DOTParser.ID))) != 0): 

248 self.state = 41 

249 self.stmt() 

250 self.state = 43 

251 self._errHandler.sync(self) 

252 _la = self._input.LA(1) 

253 if _la == DOTParser.T__2: 

254 self.state = 42 

255 self.match(DOTParser.T__2) 

256 

257 self.state = 49 

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 

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

272 super().__init__(parent, invokingState) 

273 self.parser = parser 

274 

275 def node_stmt(self): 

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

277 

278 def edge_stmt(self): 

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

280 

281 def attr_stmt(self): 

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

283 

284 def gid(self, i: int = None): 

285 if i is None: 

286 return self.getTypedRuleContexts(DOTParser.GidContext) 

287 else: 

288 return self.getTypedRuleContext(DOTParser.GidContext, i) 

289 

290 def subgraph(self): 

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

292 

293 def getRuleIndex(self): 

294 return DOTParser.RULE_stmt 

295 

296 def enterRule(self, listener: ParseTreeListener): 

297 if hasattr(listener, "enterStmt"): 

298 listener.enterStmt(self) 

299 

300 def exitRule(self, listener: ParseTreeListener): 

301 if hasattr(listener, "exitStmt"): 

302 listener.exitStmt(self) 

303 

304 def stmt(self): 

305 

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

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

308 try: 

309 self.state = 58 

310 self._errHandler.sync(self) 

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

312 if la_ == 1: 

313 self.enterOuterAlt(localctx, 1) 

314 self.state = 50 

315 self.node_stmt() 

316 pass 

317 

318 elif la_ == 2: 

319 self.enterOuterAlt(localctx, 2) 

320 self.state = 51 

321 self.edge_stmt() 

322 pass 

323 

324 elif la_ == 3: 

325 self.enterOuterAlt(localctx, 3) 

326 self.state = 52 

327 self.attr_stmt() 

328 pass 

329 

330 elif la_ == 4: 

331 self.enterOuterAlt(localctx, 4) 

332 self.state = 53 

333 self.gid() 

334 self.state = 54 

335 self.match(DOTParser.T__3) 

336 self.state = 55 

337 self.gid() 

338 pass 

339 

340 elif la_ == 5: 

341 self.enterOuterAlt(localctx, 5) 

342 self.state = 57 

343 self.subgraph() 

344 pass 

345 

346 except RecognitionException as re: 

347 localctx.exception = re 

348 self._errHandler.reportError(self, re) 

349 self._errHandler.recover(self, re) 

350 finally: 

351 self.exitRule() 

352 return localctx 

353 

354 class Attr_stmtContext(ParserRuleContext): 

355 

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

357 super().__init__(parent, invokingState) 

358 self.parser = parser 

359 

360 def attr_list(self): 

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

362 

363 def GRAPH(self): 

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

365 

366 def NODE(self): 

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

368 

369 def EDGE(self): 

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

371 

372 def getRuleIndex(self): 

373 return DOTParser.RULE_attr_stmt 

374 

375 def enterRule(self, listener: ParseTreeListener): 

376 if hasattr(listener, "enterAttr_stmt"): 

377 listener.enterAttr_stmt(self) 

378 

379 def exitRule(self, listener: ParseTreeListener): 

380 if hasattr(listener, "exitAttr_stmt"): 

381 listener.exitAttr_stmt(self) 

382 

383 def attr_stmt(self): 

384 

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

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

387 self._la = 0 # Token type 

388 try: 

389 self.enterOuterAlt(localctx, 1) 

390 self.state = 60 

391 _la = self._input.LA(1) 

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

393 self._errHandler.recoverInline(self) 

394 else: 

395 self._errHandler.reportMatch(self) 

396 self.consume() 

397 self.state = 61 

398 self.attr_list() 

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 Attr_listContext(ParserRuleContext): 

408 

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

410 super().__init__(parent, invokingState) 

411 self.parser = parser 

412 

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

414 if i is None: 

415 return self.getTypedRuleContexts(DOTParser.A_listContext) 

416 else: 

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

418 

419 def getRuleIndex(self): 

420 return DOTParser.RULE_attr_list 

421 

422 def enterRule(self, listener: ParseTreeListener): 

423 if hasattr(listener, "enterAttr_list"): 

424 listener.enterAttr_list(self) 

425 

426 def exitRule(self, listener: ParseTreeListener): 

427 if hasattr(listener, "exitAttr_list"): 

428 listener.exitAttr_list(self) 

429 

430 def attr_list(self): 

431 

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

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

434 self._la = 0 # Token type 

435 try: 

436 self.enterOuterAlt(localctx, 1) 

437 self.state = 68 

438 self._errHandler.sync(self) 

439 _la = self._input.LA(1) 

440 while True: 

441 self.state = 63 

442 self.match(DOTParser.T__4) 

443 self.state = 65 

444 self._errHandler.sync(self) 

445 _la = self._input.LA(1) 

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

447 self.state = 64 

448 self.a_list() 

449 

450 self.state = 67 

451 self.match(DOTParser.T__5) 

452 self.state = 70 

453 self._errHandler.sync(self) 

454 _la = self._input.LA(1) 

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

456 break 

457 

458 except RecognitionException as re: 

459 localctx.exception = re 

460 self._errHandler.reportError(self, re) 

461 self._errHandler.recover(self, re) 

462 finally: 

463 self.exitRule() 

464 return localctx 

465 

466 class A_listContext(ParserRuleContext): 

467 

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

469 super().__init__(parent, invokingState) 

470 self.parser = parser 

471 

472 def gid(self, i: int = None): 

473 if i is None: 

474 return self.getTypedRuleContexts(DOTParser.GidContext) 

475 else: 

476 return self.getTypedRuleContext(DOTParser.GidContext, i) 

477 

478 def getRuleIndex(self): 

479 return DOTParser.RULE_a_list 

480 

481 def enterRule(self, listener: ParseTreeListener): 

482 if hasattr(listener, "enterA_list"): 

483 listener.enterA_list(self) 

484 

485 def exitRule(self, listener: ParseTreeListener): 

486 if hasattr(listener, "exitA_list"): 

487 listener.exitA_list(self) 

488 

489 def a_list(self): 

490 

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

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

493 self._la = 0 # Token type 

494 try: 

495 self.enterOuterAlt(localctx, 1) 

496 self.state = 80 

497 self._errHandler.sync(self) 

498 _la = self._input.LA(1) 

499 while True: 

500 self.state = 72 

501 self.gid() 

502 self.state = 75 

503 self._errHandler.sync(self) 

504 _la = self._input.LA(1) 

505 if _la == DOTParser.T__3: 

506 self.state = 73 

507 self.match(DOTParser.T__3) 

508 self.state = 74 

509 self.gid() 

510 

511 self.state = 78 

512 self._errHandler.sync(self) 

513 _la = self._input.LA(1) 

514 if _la == DOTParser.T__6: 

515 self.state = 77 

516 self.match(DOTParser.T__6) 

517 

518 self.state = 82 

519 self._errHandler.sync(self) 

520 _la = self._input.LA(1) 

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

522 break 

523 

524 except RecognitionException as re: 

525 localctx.exception = re 

526 self._errHandler.reportError(self, re) 

527 self._errHandler.recover(self, re) 

528 finally: 

529 self.exitRule() 

530 return localctx 

531 

532 class Edge_stmtContext(ParserRuleContext): 

533 

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

535 super().__init__(parent, invokingState) 

536 self.parser = parser 

537 

538 def edgeRHS(self): 

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

540 

541 def node_id(self): 

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

543 

544 def subgraph(self): 

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

546 

547 def attr_list(self): 

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

549 

550 def getRuleIndex(self): 

551 return DOTParser.RULE_edge_stmt 

552 

553 def enterRule(self, listener: ParseTreeListener): 

554 if hasattr(listener, "enterEdge_stmt"): 

555 listener.enterEdge_stmt(self) 

556 

557 def exitRule(self, listener: ParseTreeListener): 

558 if hasattr(listener, "exitEdge_stmt"): 

559 listener.exitEdge_stmt(self) 

560 

561 def edge_stmt(self): 

562 

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

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

565 self._la = 0 # Token type 

566 try: 

567 self.enterOuterAlt(localctx, 1) 

568 self.state = 86 

569 self._errHandler.sync(self) 

570 token = self._input.LA(1) 

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

572 self.state = 84 

573 self.node_id() 

574 pass 

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

576 self.state = 85 

577 self.subgraph() 

578 pass 

579 else: 

580 raise NoViableAltException(self) 

581 

582 self.state = 88 

583 self.edgeRHS() 

584 self.state = 90 

585 self._errHandler.sync(self) 

586 _la = self._input.LA(1) 

587 if _la == DOTParser.T__4: 

588 self.state = 89 

589 self.attr_list() 

590 

591 except RecognitionException as re: 

592 localctx.exception = re 

593 self._errHandler.reportError(self, re) 

594 self._errHandler.recover(self, re) 

595 finally: 

596 self.exitRule() 

597 return localctx 

598 

599 class EdgeRHSContext(ParserRuleContext): 

600 

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

602 super().__init__(parent, invokingState) 

603 self.parser = parser 

604 

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

606 if i is None: 

607 return self.getTypedRuleContexts(DOTParser.EdgeopContext) 

608 else: 

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

610 

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

612 if i is None: 

613 return self.getTypedRuleContexts(DOTParser.Node_idContext) 

614 else: 

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

616 

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

618 if i is None: 

619 return self.getTypedRuleContexts(DOTParser.SubgraphContext) 

620 else: 

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

622 

623 def getRuleIndex(self): 

624 return DOTParser.RULE_edgeRHS 

625 

626 def enterRule(self, listener: ParseTreeListener): 

627 if hasattr(listener, "enterEdgeRHS"): 

628 listener.enterEdgeRHS(self) 

629 

630 def exitRule(self, listener: ParseTreeListener): 

631 if hasattr(listener, "exitEdgeRHS"): 

632 listener.exitEdgeRHS(self) 

633 

634 def edgeRHS(self): 

635 

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

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

638 self._la = 0 # Token type 

639 try: 

640 self.enterOuterAlt(localctx, 1) 

641 self.state = 97 

642 self._errHandler.sync(self) 

643 _la = self._input.LA(1) 

644 while True: 

645 self.state = 92 

646 self.edgeop() 

647 self.state = 95 

648 self._errHandler.sync(self) 

649 token = self._input.LA(1) 

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

651 self.state = 93 

652 self.node_id() 

653 pass 

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

655 self.state = 94 

656 self.subgraph() 

657 pass 

658 else: 

659 raise NoViableAltException(self) 

660 

661 self.state = 99 

662 self._errHandler.sync(self) 

663 _la = self._input.LA(1) 

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

665 break 

666 

667 except RecognitionException as re: 

668 localctx.exception = re 

669 self._errHandler.reportError(self, re) 

670 self._errHandler.recover(self, re) 

671 finally: 

672 self.exitRule() 

673 return localctx 

674 

675 class EdgeopContext(ParserRuleContext): 

676 

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

678 super().__init__(parent, invokingState) 

679 self.parser = parser 

680 

681 def getRuleIndex(self): 

682 return DOTParser.RULE_edgeop 

683 

684 def enterRule(self, listener: ParseTreeListener): 

685 if hasattr(listener, "enterEdgeop"): 

686 listener.enterEdgeop(self) 

687 

688 def exitRule(self, listener: ParseTreeListener): 

689 if hasattr(listener, "exitEdgeop"): 

690 listener.exitEdgeop(self) 

691 

692 def edgeop(self): 

693 

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

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

696 self._la = 0 # Token type 

697 try: 

698 self.enterOuterAlt(localctx, 1) 

699 self.state = 101 

700 _la = self._input.LA(1) 

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

702 self._errHandler.recoverInline(self) 

703 else: 

704 self._errHandler.reportMatch(self) 

705 self.consume() 

706 except RecognitionException as re: 

707 localctx.exception = re 

708 self._errHandler.reportError(self, re) 

709 self._errHandler.recover(self, re) 

710 finally: 

711 self.exitRule() 

712 return localctx 

713 

714 class Node_stmtContext(ParserRuleContext): 

715 

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

717 super().__init__(parent, invokingState) 

718 self.parser = parser 

719 

720 def node_id(self): 

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

722 

723 def attr_list(self): 

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

725 

726 def getRuleIndex(self): 

727 return DOTParser.RULE_node_stmt 

728 

729 def enterRule(self, listener: ParseTreeListener): 

730 if hasattr(listener, "enterNode_stmt"): 

731 listener.enterNode_stmt(self) 

732 

733 def exitRule(self, listener: ParseTreeListener): 

734 if hasattr(listener, "exitNode_stmt"): 

735 listener.exitNode_stmt(self) 

736 

737 def node_stmt(self): 

738 

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

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

741 self._la = 0 # Token type 

742 try: 

743 self.enterOuterAlt(localctx, 1) 

744 self.state = 103 

745 self.node_id() 

746 self.state = 105 

747 self._errHandler.sync(self) 

748 _la = self._input.LA(1) 

749 if _la == DOTParser.T__4: 

750 self.state = 104 

751 self.attr_list() 

752 

753 except RecognitionException as re: 

754 localctx.exception = re 

755 self._errHandler.reportError(self, re) 

756 self._errHandler.recover(self, re) 

757 finally: 

758 self.exitRule() 

759 return localctx 

760 

761 class Node_idContext(ParserRuleContext): 

762 

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

764 super().__init__(parent, invokingState) 

765 self.parser = parser 

766 

767 def gid(self): 

768 return self.getTypedRuleContext(DOTParser.GidContext, 0) 

769 

770 def port(self): 

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

772 

773 def getRuleIndex(self): 

774 return DOTParser.RULE_node_id 

775 

776 def enterRule(self, listener: ParseTreeListener): 

777 if hasattr(listener, "enterNode_id"): 

778 listener.enterNode_id(self) 

779 

780 def exitRule(self, listener: ParseTreeListener): 

781 if hasattr(listener, "exitNode_id"): 

782 listener.exitNode_id(self) 

783 

784 def node_id(self): 

785 

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

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

788 self._la = 0 # Token type 

789 try: 

790 self.enterOuterAlt(localctx, 1) 

791 self.state = 107 

792 self.gid() 

793 self.state = 109 

794 self._errHandler.sync(self) 

795 _la = self._input.LA(1) 

796 if _la == DOTParser.T__9: 

797 self.state = 108 

798 self.port() 

799 

800 except RecognitionException as re: 

801 localctx.exception = re 

802 self._errHandler.reportError(self, re) 

803 self._errHandler.recover(self, re) 

804 finally: 

805 self.exitRule() 

806 return localctx 

807 

808 class PortContext(ParserRuleContext): 

809 

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

811 super().__init__(parent, invokingState) 

812 self.parser = parser 

813 

814 def gid(self): 

815 return self.getTypedRuleContext(DOTParser.GidContext, 0) 

816 

817 def compass_pt(self): 

818 return self.getTypedRuleContext(DOTParser.Compass_ptContext, 0) 

819 

820 def getRuleIndex(self): 

821 return DOTParser.RULE_port 

822 

823 def enterRule(self, listener: ParseTreeListener): 

824 if hasattr(listener, "enterPort"): 

825 listener.enterPort(self) 

826 

827 def exitRule(self, listener: ParseTreeListener): 

828 if hasattr(listener, "exitPort"): 

829 listener.exitPort(self) 

830 

831 def port(self): 

832 

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

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

835 self._la = 0 # Token type 

836 try: 

837 self.state = 119 

838 self._errHandler.sync(self) 

839 la_ = self._interp.adaptivePredict(self._input, 17, self._ctx) 

840 if la_ == 1: 

841 self.enterOuterAlt(localctx, 1) 

842 self.state = 111 

843 self.match(DOTParser.T__9) 

844 self.state = 112 

845 self.gid() 

846 self.state = 115 

847 self._errHandler.sync(self) 

848 _la = self._input.LA(1) 

849 if _la == DOTParser.T__9: 

850 self.state = 113 

851 self.match(DOTParser.T__9) 

852 self.state = 114 

853 self.compass_pt() 

854 

855 pass 

856 

857 elif la_ == 2: 

858 self.enterOuterAlt(localctx, 2) 

859 self.state = 117 

860 self.match(DOTParser.T__9) 

861 self.state = 118 

862 self.compass_pt() 

863 pass 

864 

865 except RecognitionException as re: 

866 localctx.exception = re 

867 self._errHandler.reportError(self, re) 

868 self._errHandler.recover(self, re) 

869 finally: 

870 self.exitRule() 

871 return localctx 

872 

873 class SubgraphContext(ParserRuleContext): 

874 

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

876 super().__init__(parent, invokingState) 

877 self.parser = parser 

878 

879 def stmt_list(self): 

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

881 

882 def SUBGRAPH(self): 

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

884 

885 def gid(self): 

886 return self.getTypedRuleContext(DOTParser.GidContext, 0) 

887 

888 def getRuleIndex(self): 

889 return DOTParser.RULE_subgraph 

890 

891 def enterRule(self, listener: ParseTreeListener): 

892 if hasattr(listener, "enterSubgraph"): 

893 listener.enterSubgraph(self) 

894 

895 def exitRule(self, listener: ParseTreeListener): 

896 if hasattr(listener, "exitSubgraph"): 

897 listener.exitSubgraph(self) 

898 

899 def subgraph(self): 

900 

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

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

903 self._la = 0 # Token type 

904 try: 

905 self.enterOuterAlt(localctx, 1) 

906 self.state = 125 

907 self._errHandler.sync(self) 

908 _la = self._input.LA(1) 

909 if _la == DOTParser.SUBGRAPH: 

910 self.state = 121 

911 self.match(DOTParser.SUBGRAPH) 

912 self.state = 123 

913 self._errHandler.sync(self) 

914 _la = self._input.LA(1) 

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

916 self.state = 122 

917 self.gid() 

918 

919 self.state = 127 

920 self.match(DOTParser.T__0) 

921 self.state = 128 

922 self.stmt_list() 

923 self.state = 129 

924 self.match(DOTParser.T__1) 

925 except RecognitionException as re: 

926 localctx.exception = re 

927 self._errHandler.reportError(self, re) 

928 self._errHandler.recover(self, re) 

929 finally: 

930 self.exitRule() 

931 return localctx 

932 

933 class Compass_ptContext(ParserRuleContext): 

934 

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

936 super().__init__(parent, invokingState) 

937 self.parser = parser 

938 

939 def ID(self): 

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

941 

942 def getRuleIndex(self): 

943 return DOTParser.RULE_compass_pt 

944 

945 def enterRule(self, listener: ParseTreeListener): 

946 if hasattr(listener, "enterCompass_pt"): 

947 listener.enterCompass_pt(self) 

948 

949 def exitRule(self, listener: ParseTreeListener): 

950 if hasattr(listener, "exitCompass_pt"): 

951 listener.exitCompass_pt(self) 

952 

953 def compass_pt(self): 

954 

955 localctx = DOTParser.Compass_ptContext(self, self._ctx, self.state) 

956 self.enterRule(localctx, 26, self.RULE_compass_pt) 

957 self._la = 0 # Token type 

958 try: 

959 self.enterOuterAlt(localctx, 1) 

960 self.state = 131 

961 _la = self._input.LA(1) 

962 if not(_la == DOTParser.T__10 or _la == DOTParser.ID): 

963 self._errHandler.recoverInline(self) 

964 else: 

965 self._errHandler.reportMatch(self) 

966 self.consume() 

967 except RecognitionException as re: 

968 localctx.exception = re 

969 self._errHandler.reportError(self, re) 

970 self._errHandler.recover(self, re) 

971 finally: 

972 self.exitRule() 

973 return localctx 

974 

975 class GidContext(ParserRuleContext): 

976 

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

978 super().__init__(parent, invokingState) 

979 self.parser = parser 

980 

981 def ID(self): 

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

983 

984 def STRING(self): 

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

986 

987 def HTML_STRING(self): 

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

989 

990 def NUMBER(self): 

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

992 

993 def getRuleIndex(self): 

994 return DOTParser.RULE_gid 

995 

996 def enterRule(self, listener: ParseTreeListener): 

997 if hasattr(listener, "enterGid"): 

998 listener.enterGid(self) 

999 

1000 def exitRule(self, listener: ParseTreeListener): 

1001 if hasattr(listener, "exitGid"): 

1002 listener.exitGid(self) 

1003 

1004 def gid(self): 

1005 

1006 localctx = DOTParser.GidContext(self, self._ctx, self.state) 

1007 self.enterRule(localctx, 28, self.RULE_gid) 

1008 self._la = 0 # Token type 

1009 try: 

1010 self.enterOuterAlt(localctx, 1) 

1011 self.state = 133 

1012 _la = self._input.LA(1) 

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

1014 self._errHandler.recoverInline(self) 

1015 else: 

1016 self._errHandler.reportMatch(self) 

1017 self.consume() 

1018 except RecognitionException as re: 

1019 localctx.exception = re 

1020 self._errHandler.reportError(self, re) 

1021 self._errHandler.recover(self, re) 

1022 finally: 

1023 self.exitRule() 

1024 return localctx