1 #!/usr/bin/env python3.8
2 # @generated by pegen from metagrammar.gram
3
4 import ast
5 import sys
6 import tokenize
7
8 from typing import Any, Optional
9
10 from pegen.parser import memoize, memoize_left_rec, logger, Parser
11 from ast import literal_eval
12
13 from 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.
42 class ESC[4;38;5;81mGeneratedParser(ESC[4;38;5;149mParser):
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
653 if __name__ == '__main__':
654 from pegen.parser import simple_parser_main
655 simple_parser_main(GeneratedParser)