1#!/usr/bin/env python3.8 2# @generated by pegen from metagrammar.gram 3 4import ast 5import sys 6import tokenize 7 8from typing import Any, Optional 9 10from pegen.parser import memoize, memoize_left_rec, logger, Parser 11from ast import literal_eval 12 13from pegen.grammar import ( 14 Alt, 15 Cut, 16 Forced, 17 Gather, 18 Group, 19 Item, 20 Lookahead, 21 LookaheadOrCut, 22 MetaTuple, 23 MetaList, 24 NameLeaf, 25 NamedItem, 26 NamedItemList, 27 NegativeLookahead, 28 Opt, 29 Plain, 30 PositiveLookahead, 31 Repeat0, 32 Repeat1, 33 Rhs, 34 Rule, 35 RuleList, 36 RuleName, 37 Grammar, 38 StringLeaf, 39) 40 41# Keywords and soft keywords are listed at the end of the parser definition. 42class GeneratedParser(Parser): 43 44 @memoize 45 def start(self) -> Optional[Grammar]: 46 # start: grammar $ 47 mark = self._mark() 48 if ( 49 (grammar := self.grammar()) 50 and 51 (_endmarker := self.expect('ENDMARKER')) 52 ): 53 return grammar 54 self._reset(mark) 55 return None 56 57 @memoize 58 def grammar(self) -> Optional[Grammar]: 59 # grammar: metas rules | rules 60 mark = self._mark() 61 if ( 62 (metas := self.metas()) 63 and 64 (rules := self.rules()) 65 ): 66 return Grammar ( rules , metas ) 67 self._reset(mark) 68 if ( 69 (rules := self.rules()) 70 ): 71 return Grammar ( rules , [] ) 72 self._reset(mark) 73 return None 74 75 @memoize 76 def metas(self) -> Optional[MetaList]: 77 # metas: meta metas | meta 78 mark = self._mark() 79 if ( 80 (meta := self.meta()) 81 and 82 (metas := self.metas()) 83 ): 84 return [meta] + metas 85 self._reset(mark) 86 if ( 87 (meta := self.meta()) 88 ): 89 return [meta] 90 self._reset(mark) 91 return None 92 93 @memoize 94 def meta(self) -> Optional[MetaTuple]: 95 # meta: "@" NAME NEWLINE | "@" NAME NAME NEWLINE | "@" NAME STRING NEWLINE 96 mark = self._mark() 97 if ( 98 (literal := self.expect("@")) 99 and 100 (name := self.name()) 101 and 102 (_newline := self.expect('NEWLINE')) 103 ): 104 return ( name . string , None ) 105 self._reset(mark) 106 if ( 107 (literal := self.expect("@")) 108 and 109 (a := self.name()) 110 and 111 (b := self.name()) 112 and 113 (_newline := self.expect('NEWLINE')) 114 ): 115 return ( a . string , b . string ) 116 self._reset(mark) 117 if ( 118 (literal := self.expect("@")) 119 and 120 (name := self.name()) 121 and 122 (string := self.string()) 123 and 124 (_newline := self.expect('NEWLINE')) 125 ): 126 return ( name . string , literal_eval ( string . string ) ) 127 self._reset(mark) 128 return None 129 130 @memoize 131 def rules(self) -> Optional[RuleList]: 132 # rules: rule rules | rule 133 mark = self._mark() 134 if ( 135 (rule := self.rule()) 136 and 137 (rules := self.rules()) 138 ): 139 return [rule] + rules 140 self._reset(mark) 141 if ( 142 (rule := self.rule()) 143 ): 144 return [rule] 145 self._reset(mark) 146 return None 147 148 @memoize 149 def rule(self) -> Optional[Rule]: 150 # rule: rulename memoflag? ":" alts NEWLINE INDENT more_alts DEDENT | rulename memoflag? ":" NEWLINE INDENT more_alts DEDENT | rulename memoflag? ":" alts NEWLINE 151 mark = self._mark() 152 if ( 153 (rulename := self.rulename()) 154 and 155 (opt := self.memoflag(),) 156 and 157 (literal := self.expect(":")) 158 and 159 (alts := self.alts()) 160 and 161 (_newline := self.expect('NEWLINE')) 162 and 163 (_indent := self.expect('INDENT')) 164 and 165 (more_alts := self.more_alts()) 166 and 167 (_dedent := self.expect('DEDENT')) 168 ): 169 return Rule ( rulename [0] , rulename [1] , Rhs ( alts . alts + more_alts . alts ) , memo = opt ) 170 self._reset(mark) 171 if ( 172 (rulename := self.rulename()) 173 and 174 (opt := self.memoflag(),) 175 and 176 (literal := self.expect(":")) 177 and 178 (_newline := self.expect('NEWLINE')) 179 and 180 (_indent := self.expect('INDENT')) 181 and 182 (more_alts := self.more_alts()) 183 and 184 (_dedent := self.expect('DEDENT')) 185 ): 186 return Rule ( rulename [0] , rulename [1] , more_alts , memo = opt ) 187 self._reset(mark) 188 if ( 189 (rulename := self.rulename()) 190 and 191 (opt := self.memoflag(),) 192 and 193 (literal := self.expect(":")) 194 and 195 (alts := self.alts()) 196 and 197 (_newline := self.expect('NEWLINE')) 198 ): 199 return Rule ( rulename [0] , rulename [1] , alts , memo = opt ) 200 self._reset(mark) 201 return None 202 203 @memoize 204 def rulename(self) -> Optional[RuleName]: 205 # rulename: NAME annotation | NAME 206 mark = self._mark() 207 if ( 208 (name := self.name()) 209 and 210 (annotation := self.annotation()) 211 ): 212 return ( name . string , annotation ) 213 self._reset(mark) 214 if ( 215 (name := self.name()) 216 ): 217 return ( name . string , None ) 218 self._reset(mark) 219 return None 220 221 @memoize 222 def memoflag(self) -> Optional[str]: 223 # memoflag: '(' "memo" ')' 224 mark = self._mark() 225 if ( 226 (literal := self.expect('(')) 227 and 228 (literal_1 := self.expect("memo")) 229 and 230 (literal_2 := self.expect(')')) 231 ): 232 return "memo" 233 self._reset(mark) 234 return None 235 236 @memoize 237 def alts(self) -> Optional[Rhs]: 238 # alts: alt "|" alts | alt 239 mark = self._mark() 240 if ( 241 (alt := self.alt()) 242 and 243 (literal := self.expect("|")) 244 and 245 (alts := self.alts()) 246 ): 247 return Rhs ( [alt] + alts . alts ) 248 self._reset(mark) 249 if ( 250 (alt := self.alt()) 251 ): 252 return Rhs ( [alt] ) 253 self._reset(mark) 254 return None 255 256 @memoize 257 def more_alts(self) -> Optional[Rhs]: 258 # more_alts: "|" alts NEWLINE more_alts | "|" alts NEWLINE 259 mark = self._mark() 260 if ( 261 (literal := self.expect("|")) 262 and 263 (alts := self.alts()) 264 and 265 (_newline := self.expect('NEWLINE')) 266 and 267 (more_alts := self.more_alts()) 268 ): 269 return Rhs ( alts . alts + more_alts . alts ) 270 self._reset(mark) 271 if ( 272 (literal := self.expect("|")) 273 and 274 (alts := self.alts()) 275 and 276 (_newline := self.expect('NEWLINE')) 277 ): 278 return Rhs ( alts . alts ) 279 self._reset(mark) 280 return None 281 282 @memoize 283 def alt(self) -> Optional[Alt]: 284 # alt: items '$' action | items '$' | items action | items 285 mark = self._mark() 286 if ( 287 (items := self.items()) 288 and 289 (literal := self.expect('$')) 290 and 291 (action := self.action()) 292 ): 293 return Alt ( items + [NamedItem ( None , NameLeaf ( 'ENDMARKER' ) )] , action = action ) 294 self._reset(mark) 295 if ( 296 (items := self.items()) 297 and 298 (literal := self.expect('$')) 299 ): 300 return Alt ( items + [NamedItem ( None , NameLeaf ( 'ENDMARKER' ) )] , action = None ) 301 self._reset(mark) 302 if ( 303 (items := self.items()) 304 and 305 (action := self.action()) 306 ): 307 return Alt ( items , action = action ) 308 self._reset(mark) 309 if ( 310 (items := self.items()) 311 ): 312 return Alt ( items , action = None ) 313 self._reset(mark) 314 return None 315 316 @memoize 317 def items(self) -> Optional[NamedItemList]: 318 # items: named_item items | named_item 319 mark = self._mark() 320 if ( 321 (named_item := self.named_item()) 322 and 323 (items := self.items()) 324 ): 325 return [named_item] + items 326 self._reset(mark) 327 if ( 328 (named_item := self.named_item()) 329 ): 330 return [named_item] 331 self._reset(mark) 332 return None 333 334 @memoize 335 def named_item(self) -> Optional[NamedItem]: 336 # named_item: NAME annotation '=' ~ item | NAME '=' ~ item | item | forced_atom | lookahead 337 mark = self._mark() 338 cut = False 339 if ( 340 (name := self.name()) 341 and 342 (annotation := self.annotation()) 343 and 344 (literal := self.expect('=')) 345 and 346 (cut := True) 347 and 348 (item := self.item()) 349 ): 350 return NamedItem ( name . string , item , annotation ) 351 self._reset(mark) 352 if cut: return None 353 cut = False 354 if ( 355 (name := self.name()) 356 and 357 (literal := self.expect('=')) 358 and 359 (cut := True) 360 and 361 (item := self.item()) 362 ): 363 return NamedItem ( name . string , item ) 364 self._reset(mark) 365 if cut: return None 366 if ( 367 (item := self.item()) 368 ): 369 return NamedItem ( None , item ) 370 self._reset(mark) 371 if ( 372 (forced := self.forced_atom()) 373 ): 374 return NamedItem ( None , forced ) 375 self._reset(mark) 376 if ( 377 (it := self.lookahead()) 378 ): 379 return NamedItem ( None , it ) 380 self._reset(mark) 381 return None 382 383 @memoize 384 def forced_atom(self) -> Optional[Forced]: 385 # forced_atom: '&' '&' ~ atom 386 mark = self._mark() 387 cut = False 388 if ( 389 (literal := self.expect('&')) 390 and 391 (literal_1 := self.expect('&')) 392 and 393 (cut := True) 394 and 395 (atom := self.atom()) 396 ): 397 return Forced ( atom ) 398 self._reset(mark) 399 if cut: return None 400 return None 401 402 @memoize 403 def lookahead(self) -> Optional[LookaheadOrCut]: 404 # lookahead: '&' ~ atom | '!' ~ atom | '~' 405 mark = self._mark() 406 cut = False 407 if ( 408 (literal := self.expect('&')) 409 and 410 (cut := True) 411 and 412 (atom := self.atom()) 413 ): 414 return PositiveLookahead ( atom ) 415 self._reset(mark) 416 if cut: return None 417 cut = False 418 if ( 419 (literal := self.expect('!')) 420 and 421 (cut := True) 422 and 423 (atom := self.atom()) 424 ): 425 return NegativeLookahead ( atom ) 426 self._reset(mark) 427 if cut: return None 428 if ( 429 (literal := self.expect('~')) 430 ): 431 return Cut ( ) 432 self._reset(mark) 433 return None 434 435 @memoize 436 def item(self) -> Optional[Item]: 437 # item: '[' ~ alts ']' | atom '?' | atom '*' | atom '+' | atom '.' atom '+' | atom 438 mark = self._mark() 439 cut = False 440 if ( 441 (literal := self.expect('[')) 442 and 443 (cut := True) 444 and 445 (alts := self.alts()) 446 and 447 (literal_1 := self.expect(']')) 448 ): 449 return Opt ( alts ) 450 self._reset(mark) 451 if cut: return None 452 if ( 453 (atom := self.atom()) 454 and 455 (literal := self.expect('?')) 456 ): 457 return Opt ( atom ) 458 self._reset(mark) 459 if ( 460 (atom := self.atom()) 461 and 462 (literal := self.expect('*')) 463 ): 464 return Repeat0 ( atom ) 465 self._reset(mark) 466 if ( 467 (atom := self.atom()) 468 and 469 (literal := self.expect('+')) 470 ): 471 return Repeat1 ( atom ) 472 self._reset(mark) 473 if ( 474 (sep := self.atom()) 475 and 476 (literal := self.expect('.')) 477 and 478 (node := self.atom()) 479 and 480 (literal_1 := self.expect('+')) 481 ): 482 return Gather ( sep , node ) 483 self._reset(mark) 484 if ( 485 (atom := self.atom()) 486 ): 487 return atom 488 self._reset(mark) 489 return None 490 491 @memoize 492 def atom(self) -> Optional[Plain]: 493 # atom: '(' ~ alts ')' | NAME | STRING 494 mark = self._mark() 495 cut = False 496 if ( 497 (literal := self.expect('(')) 498 and 499 (cut := True) 500 and 501 (alts := self.alts()) 502 and 503 (literal_1 := self.expect(')')) 504 ): 505 return Group ( alts ) 506 self._reset(mark) 507 if cut: return None 508 if ( 509 (name := self.name()) 510 ): 511 return NameLeaf ( name . string ) 512 self._reset(mark) 513 if ( 514 (string := self.string()) 515 ): 516 return StringLeaf ( string . string ) 517 self._reset(mark) 518 return None 519 520 @memoize 521 def action(self) -> Optional[str]: 522 # action: "{" ~ target_atoms "}" 523 mark = self._mark() 524 cut = False 525 if ( 526 (literal := self.expect("{")) 527 and 528 (cut := True) 529 and 530 (target_atoms := self.target_atoms()) 531 and 532 (literal_1 := self.expect("}")) 533 ): 534 return target_atoms 535 self._reset(mark) 536 if cut: return None 537 return None 538 539 @memoize 540 def annotation(self) -> Optional[str]: 541 # annotation: "[" ~ target_atoms "]" 542 mark = self._mark() 543 cut = False 544 if ( 545 (literal := self.expect("[")) 546 and 547 (cut := True) 548 and 549 (target_atoms := self.target_atoms()) 550 and 551 (literal_1 := self.expect("]")) 552 ): 553 return target_atoms 554 self._reset(mark) 555 if cut: return None 556 return None 557 558 @memoize 559 def target_atoms(self) -> Optional[str]: 560 # target_atoms: target_atom target_atoms | target_atom 561 mark = self._mark() 562 if ( 563 (target_atom := self.target_atom()) 564 and 565 (target_atoms := self.target_atoms()) 566 ): 567 return target_atom + " " + target_atoms 568 self._reset(mark) 569 if ( 570 (target_atom := self.target_atom()) 571 ): 572 return target_atom 573 self._reset(mark) 574 return None 575 576 @memoize 577 def target_atom(self) -> Optional[str]: 578 # target_atom: "{" ~ target_atoms? "}" | "[" ~ target_atoms? "]" | NAME "*" | NAME | NUMBER | STRING | "?" | ":" | !"}" !"]" OP 579 mark = self._mark() 580 cut = False 581 if ( 582 (literal := self.expect("{")) 583 and 584 (cut := True) 585 and 586 (atoms := self.target_atoms(),) 587 and 588 (literal_1 := self.expect("}")) 589 ): 590 return "{" + ( atoms or "" ) + "}" 591 self._reset(mark) 592 if cut: return None 593 cut = False 594 if ( 595 (literal := self.expect("[")) 596 and 597 (cut := True) 598 and 599 (atoms := self.target_atoms(),) 600 and 601 (literal_1 := self.expect("]")) 602 ): 603 return "[" + ( atoms or "" ) + "]" 604 self._reset(mark) 605 if cut: return None 606 if ( 607 (name := self.name()) 608 and 609 (literal := self.expect("*")) 610 ): 611 return name . string + "*" 612 self._reset(mark) 613 if ( 614 (name := self.name()) 615 ): 616 return name . string 617 self._reset(mark) 618 if ( 619 (number := self.number()) 620 ): 621 return number . string 622 self._reset(mark) 623 if ( 624 (string := self.string()) 625 ): 626 return string . string 627 self._reset(mark) 628 if ( 629 (literal := self.expect("?")) 630 ): 631 return "?" 632 self._reset(mark) 633 if ( 634 (literal := self.expect(":")) 635 ): 636 return ":" 637 self._reset(mark) 638 if ( 639 self.negative_lookahead(self.expect, "}") 640 and 641 self.negative_lookahead(self.expect, "]") 642 and 643 (op := self.op()) 644 ): 645 return op . string 646 self._reset(mark) 647 return None 648 649 KEYWORDS = () 650 SOFT_KEYWORDS = ('memo',) 651 652 653if __name__ == '__main__': 654 from pegen.parser import simple_parser_main 655 simple_parser_main(GeneratedParser) 656