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