Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
allendowney
GitHub Repository: allendowney/cpython
 Path: blob/main/Tools/peg_generator/pegen/grammar_parser.py
12 views
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 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


653
if __name__ == '__main__':

654
    from pegen.parser import simple_parser_main

655
    simple_parser_main(GeneratedParser)

656


657