Grcov report - grammar.rs

1

// auto-generated: "lalrpop 0.20.0"

2

// sha3: 0541a5c8cbc7df293b7d9148130d6ecfffe67d17a7aaf2f2fc15fa20d053d30a

3

use super::generate_class;

4

use super::lexer;

5

use super::lexer::{Token, LexicalError};

6

use regex_syntax::hir::{self, Hir};

7

#[allow(unused_extern_crates)]

8

extern crate lalrpop_util as __lalrpop_util;

9

#[allow(unused_imports)]

10

use self::__lalrpop_util::state_machine as __state_machine;

11

extern crate core;

12

extern crate alloc;

13

14

#[rustfmt::skip]

15

#[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy::all)]

16

mod __parse__Regex {

17

18

    use super::super::generate_class;

19

    use super::super::lexer;

20

    use super::super::lexer::{Token, LexicalError};

21

    use regex_syntax::hir::{self, Hir};

22

    #[allow(unused_extern_crates)]

23

    extern crate lalrpop_util as __lalrpop_util;

24

    #[allow(unused_imports)]

25

    use self::__lalrpop_util::state_machine as __state_machine;

26

    extern crate core;

27

    extern crate alloc;

28

    use super::__ToTriple;

29

    #[allow(dead_code)]

30

    pub(crate) enum __Symbol<>

31

32

        Variant0(lexer::Token),

33

        Variant1(Token),

34

        Variant2(Hir),

35

        Variant3(core::option::Option<lexer::Token>),

36

        Variant4(alloc::vec::Vec<Token>),

37

        Variant5(alloc::vec::Vec<Hir>),

38

39

    const __ACTION: &[i8] = &[

40

        // State 0

41

        4, 22, 23, 24, 25, 5, 6, 26, -23, 0, 0, 0, 0, 0,

42

        // State 1

43

        0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, -75, 0,

44

        // State 2

45

        4, 22, 23, 24, 25, 5, 6, 26, -24, 0, 0, 0, -24, 0,

46

        // State 3

47

        33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,

48

        // State 4

49

        47, 10, 48, 49, 50, 51, 52, 53, 54, 55, 56, 11, 57, 58,

50

        // State 5

51

        4, 22, 23, 24, 25, 5, 6, 26, -23, 0, 0, 0, -23, 0,

52

        // State 6

53

        0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, -76, 0,

54

        // State 7

55

        4, 22, 23, 24, 25, 5, 6, 26, -23, 0, 0, 0, -23, 0,

56

        // State 8

57

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,

58

        // State 9

59

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 14, 75, 76,

60

        // State 10

61

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 77, 75, 76,

62

        // State 11

63

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 80, 75, 76,

64

        // State 12

65

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 81, 75, 76,

66

        // State 13

67

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 82, 75, 76,

68

        // State 14

69

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 83, 75, 76,

70

        // State 15

71

        63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 84, 75, 76,

72

        // State 16

73

        -57, -57, -57, -57, -57, -57, -57, -57, -57, 27, 28, 0, -57, 29,

74

        // State 17

75

        0, 0, 0, 0, 0, 0, 0, 0, -27, 0, 0, 0, -27, 0,

76

        // State 18

77

        -61, -61, -61, -61, -61, -61, -61, -61, -61, 0, 0, 0, -61, 0,

78

        // State 19

79

        -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, 0, -16, -16,

80

        // State 20

81

        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

82

        // State 21

83

        -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, 0, -18, -18,

84

        // State 22

85

        -21, -21, -21, -21, -21, -21, -21, -21, -21, -21, -21, 0, -21, -21,

86

        // State 23

87

        -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, 0, -19, -19,

88

        // State 24

89

        -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, 0, -17, -17,

90

        // State 25

91

        -22, -22, -22, -22, -22, -22, -22, -22, -22, -22, -22, 0, -22, -22,

92

        // State 26

93

        -59, -59, -59, -59, -59, -59, -59, -59, -59, 0, 0, 0, -59, 0,

94

        // State 27

95

        -60, -60, -60, -60, -60, -60, -60, -60, -60, 0, 0, 0, -60, 0,

96

        // State 28

97

        -58, -58, -58, -58, -58, -58, -58, -58, -58, 0, 0, 0, -58, 0,

98

        // State 29

99

        0, 0, 0, 0, 0, 0, 0, 0, -66, 0, 0, 0, -66, 0,

100

        // State 30

101

        -62, -62, -62, -62, -62, -62, -62, -62, -62, 0, 0, 0, -62, 0,

102

        // State 31

103

        -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, 0, -20, -20,

104

        // State 32

105

        -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, 0, -10, -10,

106

        // State 33

107

        -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, 0, -8, -8,

108

        // State 34

109

        -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, 0, -13, -13,

110

        // State 35

111

        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, 0, -9, -9,

112

        // State 36

113

        -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, 0, -7, -7,

114

        // State 37

115

        -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, 0, -11, -11,

116

        // State 38

117

        -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, 0, -5, -5,

118

        // State 39

119

        -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, 0, -14, -14,

120

        // State 40

121

        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1,

122

        // State 41

123

        -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 0, -3, -3,

124

        // State 42

125

        -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, 0, -4, -4,

126

        // State 43

127

        -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, 0, -12, -12,

128

        // State 44

129

        -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, 0, -6, -6,

130

        // State 45

131

        -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 0, -2, -2,

132

        // State 46

133

        -36, -36, -36, -36, -36, -36, -36, -36, -36, -36, -36, -36, -36, -36,

134

        // State 47

135

        -38, -38, -38, -38, -38, -38, -38, -38, -38, -38, -38, -38, -38, -38,

136

        // State 48

137

        -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35,

138

        // State 49

139

        -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34,

140

        // State 50

141

        -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37, -37,

142

        // State 51

143

        -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,

144

        // State 52

145

        -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39,

146

        // State 53

147

        -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28,

148

        // State 54

149

        -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, -30,

150

        // State 55

151

        -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31,

152

        // State 56

153

        -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33,

154

        // State 57

155

        -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, -29,

156

        // State 58

157

        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 78, 0,

158

        // State 59

159

        0, 0, 0, 0, 0, 0, 0, 0, -67, 0, 0, 0, -67, 0,

160

        // State 60

161

        0, 0, 0, 0, 0, 0, 0, 0, -63, 0, 0, 0, -63, 0,

162

        // State 61

163

        -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55, -55,

164

        // State 62

165

        -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, -49,

166

        // State 63

167

        -47, -47, -47, -47, -47, -47, -47, -47, -47, -47, -47, -47, -47, -47,

168

        // State 64

169

        -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51,

170

        // State 65

171

        -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48,

172

        // State 66

173

        -46, -46, -46, -46, -46, -46, -46, -46, -46, -46, -46, -46, -46, -46,

174

        // State 67

175

        -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50,

176

        // State 68

177

        -44, -44, -44, -44, -44, -44, -44, -44, -44, -44, -44, -44, -44, -44,

178

        // State 69

179

        -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, -52,

180

        // State 70

181

        -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40,

182

        // State 71

183

        -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42,

184

        // State 72

185

        -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43,

186

        // State 73

187

        -73, -73, -73, -73, -73, -73, -73, -73, -73, -73, -73, 0, -73, -73,

188

        // State 74

189

        -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, -45,

190

        // State 75

191

        -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41,

192

        // State 76

193

        -70, -70, -70, -70, -70, -70, -70, -70, -70, -70, -70, 0, -70, -70,

194

        // State 77

195

        -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, 0, -15, -15,

196

        // State 78

197

        -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, -56,

198

        // State 79

199

        -74, -74, -74, -74, -74, -74, -74, -74, -74, -74, -74, 0, -74, -74,

200

        // State 80

201

        -72, -72, -72, -72, -72, -72, -72, -72, -72, -72, -72, 0, -72, -72,

202

        // State 81

203

        -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, 0, -68, -68,

204

        // State 82

205

        -71, -71, -71, -71, -71, -71, -71, -71, -71, -71, -71, 0, -71, -71,

206

        // State 83

207

        -69, -69, -69, -69, -69, -69, -69, -69, -69, -69, -69, 0, -69, -69,

208

];

209

    fn __action(state: i8, integer: usize) -> i8 {

210

        __ACTION[(state as usize) * 14 + integer]

211

212

    const __EOF_ACTION: &[i8] = &[

213

        // State 0

214

        -23,

215

        // State 1

216

        -75,

217

        // State 2

218

        -24,

219

        // State 3

220

0,

221

        // State 4

222

0,

223

        // State 5

224

0,

225

        // State 6

226

        -76,

227

        // State 7

228

        -23,

229

        // State 8

230

0,

231

        // State 9

232

0,

233

        // State 10

234

0,

235

        // State 11

236

0,

237

        // State 12

238

0,

239

        // State 13

240

0,

241

        // State 14

242

0,

243

        // State 15

244

0,

245

        // State 16

246

        -57,

247

        // State 17

248

        -27,

249

        // State 18

250

        -61,

251

        // State 19

252

        -16,

253

        // State 20

254

        -77,

255

        // State 21

256

        -18,

257

        // State 22

258

        -21,

259

        // State 23

260

        -19,

261

        // State 24

262

        -17,

263

        // State 25

264

        -22,

265

        // State 26

266

        -59,

267

        // State 27

268

        -60,

269

        // State 28

270

        -58,

271

        // State 29

272

        -66,

273

        // State 30

274

        -62,

275

        // State 31

276

        -20,

277

        // State 32

278

        -10,

279

        // State 33

280

-8,

281

        // State 34

282

        -13,

283

        // State 35

284

-9,

285

        // State 36

286

-7,

287

        // State 37

288

        -11,

289

        // State 38

290

-5,

291

        // State 39

292

        -14,

293

        // State 40

294

-1,

295

        // State 41

296

-3,

297

        // State 42

298

-4,

299

        // State 43

300

        -12,

301

        // State 44

302

-6,

303

        // State 45

304

-2,

305

        // State 46

306

0,

307

        // State 47

308

0,

309

        // State 48

310

0,

311

        // State 49

312

0,

313

        // State 50

314

0,

315

        // State 51

316

0,

317

        // State 52

318

0,

319

        // State 53

320

0,

321

        // State 54

322

0,

323

        // State 55

324

0,

325

        // State 56

326

0,

327

        // State 57

328

0,

329

        // State 58

330

0,

331

        // State 59

332

        -67,

333

        // State 60

334

        -63,

335

        // State 61

336

0,

337

        // State 62

338

0,

339

        // State 63

340

0,

341

        // State 64

342

0,

343

        // State 65

344

0,

345

        // State 66

346

0,

347

        // State 67

348

0,

349

        // State 68

350

0,

351

        // State 69

352

0,

353

        // State 70

354

0,

355

        // State 71

356

0,

357

        // State 72

358

0,

359

        // State 73

360

        -73,

361

        // State 74

362

0,

363

        // State 75

364

0,

365

        // State 76

366

        -70,

367

        // State 77

368

        -15,

369

        // State 78

370

0,

371

        // State 79

372

        -74,

373

        // State 80

374

        -72,

375

        // State 81

376

        -68,

377

        // State 82

378

        -71,

379

        // State 83

380

        -69,

381

];

382

    fn __goto(state: i8, nt: usize) -> i8 {

383

        match nt {

384

            0 => 31,

385

            1 => 16,

386

            2 => match state {

387

                7 => 60,

388

                _ => 17,

389

},

390

            4 => 1,

391

            5 => 8,

392

            6 => match state {

393

                11..=12 | 14..=15 => 78,

394

                _ => 61,

395

},

396

            8 => match state {

397

                9 => 12,

398

                10 => 14,

399

                13 => 15,

400

                _ => 11,

401

},

402

            9 => match state {

403

                2 => 30,

404

                _ => 18,

405

},

406

            10 => 2,

407

            11 => match state {

408

                6 => 59,

409

                _ => 29,

410

},

411

            13 => 6,

412

            14 => 19,

413

            15 => match state {

414

                5 => 58,

415

                _ => 20,

416

},

417

            _ => 0,

418

419

420

    const __TERMINAL: &[&str] = &[

421

        r###"BACKSLASH"###,

422

        r###"CARET"###,

423

        r###"DASH"###,

424

        r###"DOLLAR"###,

425

        r###"DOT"###,

426

        r###"LBRACKET"###,

427

        r###"LPAREN"###,

428

        r###"OTHER"###,

429

        r###"PIPE"###,

430

        r###"PLUS"###,

431

        r###"QUESTION"###,

432

        r###"RBRACKET"###,

433

        r###"RPAREN"###,

434

        r###"STAR"###,

435

];

436

    fn __expected_tokens(__state: i8) -> alloc::vec::Vec<alloc::string::String> {

437

        __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| {

438

            let next_state = __action(__state, index);

439

            if next_state == 0 {

440

                None

441

            } else {

442

                Some(alloc::string::ToString::to_string(terminal))

443

444

        }).collect()

445

446

    fn __expected_tokens_from_states<

447

        'input,

448

>(

449

        __states: &[i8],

450

        _: core::marker::PhantomData<(&'input ())>,

451

    ) -> alloc::vec::Vec<alloc::string::String>

452

453

        __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| {

454

            if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) {

455

                Some(alloc::string::ToString::to_string(terminal))

456

            } else {

457

                None

458

459

        }).collect()

460

461

    pub(crate) struct __StateMachine<'input>

462

    where

463

464

        input: &'input str,

465

        __phantom: core::marker::PhantomData<(&'input ())>,

466

467

    impl<'input> __state_machine::ParserDefinition for __StateMachine<'input>

468

    where

469

470

        type Location = usize;

471

        type Error = LexicalError;

472

        type Token = lexer::Token;

473

        type TokenIndex = usize;

474

        type Symbol = __Symbol<>;

475

        type Success = Hir;

476

        type StateIndex = i8;

477

        type Action = i8;

478

        type ReduceIndex = i8;

479

        type NonterminalIndex = usize;

480

481

        #[inline]

482

        fn start_location(&self) -> Self::Location {

483

              Default::default()

484

485

486

        #[inline]

487

        fn start_state(&self) -> Self::StateIndex {

488

489

490

491

        #[inline]

492

        fn token_to_index(&self, token: &Self::Token) -> Option<usize> {

493

            __token_to_integer(token, core::marker::PhantomData::<(&())>)

494

495

496

        #[inline]

497

        fn action(&self, state: i8, integer: usize) -> i8 {

498

            __action(state, integer)

499

500

501

        #[inline]

502

        fn error_action(&self, state: i8) -> i8 {

503

            __action(state, 14 - 1)

504

505

506

        #[inline]

507

        fn eof_action(&self, state: i8) -> i8 {

508

            __EOF_ACTION[state as usize]

509

510

511

        #[inline]

512

        fn goto(&self, state: i8, nt: usize) -> i8 {

513

            __goto(state, nt)

514

515

516

        fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {

517

            __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>)

518

519

520

        fn expected_tokens(&self, state: i8) -> alloc::vec::Vec<alloc::string::String> {

521

            __expected_tokens(state)

522

523

524

        fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec<alloc::string::String> {

525

            __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>)

526

527

528

        #[inline]

529

        fn uses_error_recovery(&self) -> bool {

530

            false

531

532

533

        #[inline]

534

        fn error_recovery_symbol(

535

            &self,

536

            recovery: __state_machine::ErrorRecovery<Self>,

537

        ) -> Self::Symbol {

538

            panic!("error recovery not enabled for this grammar")

539

540

541

        fn reduce(

542

            &mut self,

543

            action: i8,

544

            start_location: Option<&Self::Location>,

545

            states: &mut alloc::vec::Vec<i8>,

546

            symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple<Self>>,

547

        ) -> Option<__state_machine::ParseResult<Self>> {

548

            __reduce(

549

                self.input,

550

                action,

551

                start_location,

552

                states,

553

                symbols,

554

                core::marker::PhantomData::<(&())>,

555

556

557

558

        fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce<Self> {

559

            __simulate_reduce(action, core::marker::PhantomData::<(&())>)

560

561

562

    fn __token_to_integer<

563

        'input,

564

>(

565

        __token: &lexer::Token,

566

        _: core::marker::PhantomData<(&'input ())>,

567

    ) -> Option<usize>

568

569

        match *__token {

570

            lexer::Token::BACKSLASH if true => Some(0),

571

            lexer::Token::CARET if true => Some(1),

572

            lexer::Token::DASH if true => Some(2),

573

            lexer::Token::DOLLAR if true => Some(3),

574

            lexer::Token::DOT if true => Some(4),

575

            lexer::Token::LBRACKET if true => Some(5),

576

            lexer::Token::LPAREN if true => Some(6),

577

            lexer::Token::OTHER(_) if true => Some(7),

578

            lexer::Token::PIPE if true => Some(8),

579

            lexer::Token::PLUS if true => Some(9),

580

            lexer::Token::QUESTION if true => Some(10),

581

            lexer::Token::RBRACKET if true => Some(11),

582

            lexer::Token::RPAREN if true => Some(12),

583

            lexer::Token::STAR if true => Some(13),

584

            _ => None,

585

586

587

    fn __token_to_symbol<

588

        'input,

589

>(

590

        __token_index: usize,

591

        __token: lexer::Token,

592

        _: core::marker::PhantomData<(&'input ())>,

593

    ) -> __Symbol<>

594

595

        match __token_index {

596

            0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 => __Symbol::Variant0(__token),

597

            _ => unreachable!(),

598

599

600

    fn __simulate_reduce<

601

        'input,

602

>(

603

        __reduce_index: i8,

604

        _: core::marker::PhantomData<(&'input ())>,

605

    ) -> __state_machine::SimulatedReduce<__StateMachine<'input>>

606

607

        match __reduce_index {

608

            0 => {

609

                __state_machine::SimulatedReduce::Reduce {

610

                    states_to_pop: 1,

611

                    nonterminal_produced: 0,

612

613

614

            1 => {

615

                __state_machine::SimulatedReduce::Reduce {

616

                    states_to_pop: 1,

617

                    nonterminal_produced: 0,

618

619

620

            2 => {

621

                __state_machine::SimulatedReduce::Reduce {

622

                    states_to_pop: 1,

623

                    nonterminal_produced: 0,

624

625

626

            3 => {

627

                __state_machine::SimulatedReduce::Reduce {

628

                    states_to_pop: 1,

629

                    nonterminal_produced: 0,

630

631

632

            4 => {

633

                __state_machine::SimulatedReduce::Reduce {

634

                    states_to_pop: 1,

635

                    nonterminal_produced: 0,

636

637

638

            5 => {

639

                __state_machine::SimulatedReduce::Reduce {

640

                    states_to_pop: 1,

641

                    nonterminal_produced: 0,

642

643

644

            6 => {

645

                __state_machine::SimulatedReduce::Reduce {

646

                    states_to_pop: 1,

647

                    nonterminal_produced: 0,

648

649

650

            7 => {

651

                __state_machine::SimulatedReduce::Reduce {

652

                    states_to_pop: 1,

653

                    nonterminal_produced: 0,

654

655

656

            8 => {

657

                __state_machine::SimulatedReduce::Reduce {

658

                    states_to_pop: 1,

659

                    nonterminal_produced: 0,

660

661

662

            9 => {

663

                __state_machine::SimulatedReduce::Reduce {

664

                    states_to_pop: 1,

665

                    nonterminal_produced: 0,

666

667

668

            10 => {

669

                __state_machine::SimulatedReduce::Reduce {

670

                    states_to_pop: 1,

671

                    nonterminal_produced: 0,

672

673

674

            11 => {

675

                __state_machine::SimulatedReduce::Reduce {

676

                    states_to_pop: 1,

677

                    nonterminal_produced: 0,

678

679

680

            12 => {

681

                __state_machine::SimulatedReduce::Reduce {

682

                    states_to_pop: 1,

683

                    nonterminal_produced: 0,

684

685

686

            13 => {

687

                __state_machine::SimulatedReduce::Reduce {

688

                    states_to_pop: 1,

689

                    nonterminal_produced: 0,

690

691

692

            14 => {

693

                __state_machine::SimulatedReduce::Reduce {

694

                    states_to_pop: 3,

695

                    nonterminal_produced: 1,

696

697

698

            15 => {

699

                __state_machine::SimulatedReduce::Reduce {

700

                    states_to_pop: 1,

701

                    nonterminal_produced: 1,

702

703

704

            16 => {

705

                __state_machine::SimulatedReduce::Reduce {

706

                    states_to_pop: 1,

707

                    nonterminal_produced: 1,

708

709

710

            17 => {

711

                __state_machine::SimulatedReduce::Reduce {

712

                    states_to_pop: 1,

713

                    nonterminal_produced: 1,

714

715

716

            18 => {

717

                __state_machine::SimulatedReduce::Reduce {

718

                    states_to_pop: 1,

719

                    nonterminal_produced: 1,

720

721

722

            19 => {

723

                __state_machine::SimulatedReduce::Reduce {

724

                    states_to_pop: 2,

725

                    nonterminal_produced: 1,

726

727

728

            20 => {

729

                __state_machine::SimulatedReduce::Reduce {

730

                    states_to_pop: 1,

731

                    nonterminal_produced: 1,

732

733

734

            21 => {

735

                __state_machine::SimulatedReduce::Reduce {

736

                    states_to_pop: 1,

737

                    nonterminal_produced: 1,

738

739

740

            22 => {

741

                __state_machine::SimulatedReduce::Reduce {

742

                    states_to_pop: 0,

743

                    nonterminal_produced: 2,

744

745

746

            23 => {

747

                __state_machine::SimulatedReduce::Reduce {

748

                    states_to_pop: 1,

749

                    nonterminal_produced: 2,

750

751

752

            24 => {

753

                __state_machine::SimulatedReduce::Reduce {

754

                    states_to_pop: 1,

755

                    nonterminal_produced: 3,

756

757

758

            25 => {

759

                __state_machine::SimulatedReduce::Reduce {

760

                    states_to_pop: 0,

761

                    nonterminal_produced: 3,

762

763

764

            26 => {

765

                __state_machine::SimulatedReduce::Reduce {

766

                    states_to_pop: 1,

767

                    nonterminal_produced: 4,

768

769

770

            27 => {

771

                __state_machine::SimulatedReduce::Reduce {

772

                    states_to_pop: 1,

773

                    nonterminal_produced: 5,

774

775

776

            28 => {

777

                __state_machine::SimulatedReduce::Reduce {

778

                    states_to_pop: 1,

779

                    nonterminal_produced: 5,

780

781

782

            29 => {

783

                __state_machine::SimulatedReduce::Reduce {

784

                    states_to_pop: 1,

785

                    nonterminal_produced: 5,

786

787

788

            30 => {

789

                __state_machine::SimulatedReduce::Reduce {

790

                    states_to_pop: 1,

791

                    nonterminal_produced: 5,

792

793

794

            31 => {

795

                __state_machine::SimulatedReduce::Reduce {

796

                    states_to_pop: 1,

797

                    nonterminal_produced: 5,

798

799

800

            32 => {

801

                __state_machine::SimulatedReduce::Reduce {

802

                    states_to_pop: 1,

803

                    nonterminal_produced: 5,

804

805

806

            33 => {

807

                __state_machine::SimulatedReduce::Reduce {

808

                    states_to_pop: 1,

809

                    nonterminal_produced: 5,

810

811

812

            34 => {

813

                __state_machine::SimulatedReduce::Reduce {

814

                    states_to_pop: 1,

815

                    nonterminal_produced: 5,

816

817

818

            35 => {

819

                __state_machine::SimulatedReduce::Reduce {

820

                    states_to_pop: 1,

821

                    nonterminal_produced: 5,

822

823

824

            36 => {

825

                __state_machine::SimulatedReduce::Reduce {

826

                    states_to_pop: 1,

827

                    nonterminal_produced: 5,

828

829

830

            37 => {

831

                __state_machine::SimulatedReduce::Reduce {

832

                    states_to_pop: 1,

833

                    nonterminal_produced: 5,

834

835

836

            38 => {

837

                __state_machine::SimulatedReduce::Reduce {

838

                    states_to_pop: 1,

839

                    nonterminal_produced: 5,

840

841

842

            39 => {

843

                __state_machine::SimulatedReduce::Reduce {

844

                    states_to_pop: 1,

845

                    nonterminal_produced: 6,

846

847

848

            40 => {

849

                __state_machine::SimulatedReduce::Reduce {

850

                    states_to_pop: 1,

851

                    nonterminal_produced: 6,

852

853

854

            41 => {

855

                __state_machine::SimulatedReduce::Reduce {

856

                    states_to_pop: 1,

857

                    nonterminal_produced: 6,

858

859

860

            42 => {

861

                __state_machine::SimulatedReduce::Reduce {

862

                    states_to_pop: 1,

863

                    nonterminal_produced: 6,

864

865

866

            43 => {

867

                __state_machine::SimulatedReduce::Reduce {

868

                    states_to_pop: 1,

869

                    nonterminal_produced: 6,

870

871

872

            44 => {

873

                __state_machine::SimulatedReduce::Reduce {

874

                    states_to_pop: 1,

875

                    nonterminal_produced: 6,

876

877

878

            45 => {

879

                __state_machine::SimulatedReduce::Reduce {

880

                    states_to_pop: 1,

881

                    nonterminal_produced: 6,

882

883

884

            46 => {

885

                __state_machine::SimulatedReduce::Reduce {

886

                    states_to_pop: 1,

887

                    nonterminal_produced: 6,

888

889

890

            47 => {

891

                __state_machine::SimulatedReduce::Reduce {

892

                    states_to_pop: 1,

893

                    nonterminal_produced: 6,

894

895

896

            48 => {

897

                __state_machine::SimulatedReduce::Reduce {

898

                    states_to_pop: 1,

899

                    nonterminal_produced: 6,

900

901

902

            49 => {

903

                __state_machine::SimulatedReduce::Reduce {

904

                    states_to_pop: 1,

905

                    nonterminal_produced: 6,

906

907

908

            50 => {

909

                __state_machine::SimulatedReduce::Reduce {

910

                    states_to_pop: 1,

911

                    nonterminal_produced: 6,

912

913

914

            51 => {

915

                __state_machine::SimulatedReduce::Reduce {

916

                    states_to_pop: 1,

917

                    nonterminal_produced: 6,

918

919

920

            52 => {

921

                __state_machine::SimulatedReduce::Reduce {

922

                    states_to_pop: 0,

923

                    nonterminal_produced: 7,

924

925

926

            53 => {

927

                __state_machine::SimulatedReduce::Reduce {

928

                    states_to_pop: 1,

929

                    nonterminal_produced: 7,

930

931

932

            54 => {

933

                __state_machine::SimulatedReduce::Reduce {

934

                    states_to_pop: 1,

935

                    nonterminal_produced: 8,

936

937

938

            55 => {

939

                __state_machine::SimulatedReduce::Reduce {

940

                    states_to_pop: 2,

941

                    nonterminal_produced: 8,

942

943

944

            56 => {

945

                __state_machine::SimulatedReduce::Reduce {

946

                    states_to_pop: 1,

947

                    nonterminal_produced: 9,

948

949

950

            57 => {

951

                __state_machine::SimulatedReduce::Reduce {

952

                    states_to_pop: 2,

953

                    nonterminal_produced: 9,

954

955

956

            58 => {

957

                __state_machine::SimulatedReduce::Reduce {

958

                    states_to_pop: 2,

959

                    nonterminal_produced: 9,

960

961

962

            59 => {

963

                __state_machine::SimulatedReduce::Reduce {

964

                    states_to_pop: 2,

965

                    nonterminal_produced: 9,

966

967

968

            60 => {

969

                __state_machine::SimulatedReduce::Reduce {

970

                    states_to_pop: 1,

971

                    nonterminal_produced: 10,

972

973

974

            61 => {

975

                __state_machine::SimulatedReduce::Reduce {

976

                    states_to_pop: 2,

977

                    nonterminal_produced: 10,

978

979

980

            62 => {

981

                __state_machine::SimulatedReduce::Reduce {

982

                    states_to_pop: 2,

983

                    nonterminal_produced: 11,

984

985

986

            63 => {

987

                __state_machine::SimulatedReduce::Reduce {

988

                    states_to_pop: 0,

989

                    nonterminal_produced: 12,

990

991

992

            64 => {

993

                __state_machine::SimulatedReduce::Reduce {

994

                    states_to_pop: 1,

995

                    nonterminal_produced: 12,

996

997

998

            65 => {

999

                __state_machine::SimulatedReduce::Reduce {

1000

                    states_to_pop: 1,

1001

                    nonterminal_produced: 13,

1002

1003

1004

            66 => {

1005

                __state_machine::SimulatedReduce::Reduce {

1006

                    states_to_pop: 2,

1007

                    nonterminal_produced: 13,

1008

1009

1010

            67 => {

1011

                __state_machine::SimulatedReduce::Reduce {

1012

                    states_to_pop: 4,

1013

                    nonterminal_produced: 14,

1014

1015

1016

            68 => {

1017

                __state_machine::SimulatedReduce::Reduce {

1018

                    states_to_pop: 5,

1019

                    nonterminal_produced: 14,

1020

1021

1022

            69 => {

1023

                __state_machine::SimulatedReduce::Reduce {

1024

                    states_to_pop: 3,

1025

                    nonterminal_produced: 14,

1026

1027

1028

            70 => {

1029

                __state_machine::SimulatedReduce::Reduce {

1030

                    states_to_pop: 4,

1031

                    nonterminal_produced: 14,

1032

1033

1034

            71 => {

1035

                __state_machine::SimulatedReduce::Reduce {

1036

                    states_to_pop: 4,

1037

                    nonterminal_produced: 14,

1038

1039

1040

            72 => {

1041

                __state_machine::SimulatedReduce::Reduce {

1042

                    states_to_pop: 3,

1043

                    nonterminal_produced: 14,

1044

1045

1046

            73 => {

1047

                __state_machine::SimulatedReduce::Reduce {

1048

                    states_to_pop: 4,

1049

                    nonterminal_produced: 14,

1050

1051

1052

            74 => {

1053

                __state_machine::SimulatedReduce::Reduce {

1054

                    states_to_pop: 1,

1055

                    nonterminal_produced: 15,

1056

1057

1058

            75 => {

1059

                __state_machine::SimulatedReduce::Reduce {

1060

                    states_to_pop: 2,

1061

                    nonterminal_produced: 15,

1062

1063

1064

            76 => __state_machine::SimulatedReduce::Accept,

1065

            _ => panic!("invalid reduction index {}", __reduce_index)

1066

1067

1068

    pub(crate) struct RegexParser {

1069

        _priv: (),

1070

1071

1072

    impl RegexParser {

1073

        pub(crate) fn new() -> RegexParser {

1074

            RegexParser {

1075

                _priv: (),

1076

1077

1078

1079

        #[allow(dead_code)]

1080

        pub(crate) fn parse<

1081

            'input,

1082

            __TOKEN: __ToTriple<'input, >,

1083

            __TOKENS: IntoIterator<Item=__TOKEN>,

1084

>(

1085

            &self,

1086

            input: &'input str,

1087

            __tokens0: __TOKENS,

1088

        ) -> Result<Hir, __lalrpop_util::ParseError<usize, lexer::Token, LexicalError>>

1089

1090

            let __tokens = __tokens0.into_iter();

1091

            let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t));

1092

            __state_machine::Parser::drive(

1093

                __StateMachine {

1094

                    input,

1095

                    __phantom: core::marker::PhantomData::<(&())>,

1096

},

1097

                __tokens,

1098

1099

1100

1101

    fn __accepts<

1102

        'input,

1103

>(

1104

        __error_state: Option<i8>,

1105

        __states: &[i8],

1106

        __opt_integer: Option<usize>,

1107

        _: core::marker::PhantomData<(&'input ())>,

1108

    ) -> bool

1109

1110

        let mut __states = __states.to_vec();

1111

        __states.extend(__error_state);

1112

        loop {

1113

            let mut __states_len = __states.len();

1114

            let __top = __states[__states_len - 1];

1115

            let __action = match __opt_integer {

1116

                None => __EOF_ACTION[__top as usize],

1117

                Some(__integer) => __action(__top, __integer),

1118

};

1119

            if __action == 0 { return false; }

1120

            if __action > 0 { return true; }

1121

            let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) {

1122

                __state_machine::SimulatedReduce::Reduce {

1123

                    states_to_pop, nonterminal_produced

1124

                } => (states_to_pop, nonterminal_produced),

1125

                __state_machine::SimulatedReduce::Accept => return true,

1126

};

1127

            __states_len -= __to_pop;

1128

            __states.truncate(__states_len);

1129

            let __top = __states[__states_len - 1];

1130

            let __next_state = __goto(__top, __nt);

1131

            __states.push(__next_state);

1132

1133

1134

    pub(crate) fn __reduce<

1135

        'input,

1136

>(

1137

        input: &'input str,

1138

        __action: i8,

1139

        __lookahead_start: Option<&usize>,

1140

        __states: &mut alloc::vec::Vec<i8>,

1141

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1142

        _: core::marker::PhantomData<(&'input ())>,

1143

    ) -> Option<Result<Hir,__lalrpop_util::ParseError<usize, lexer::Token, LexicalError>>>

1144

1145

        let (__pop_states, __nonterminal) = match __action {

1146

            0 => {

1147

                __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1148

1149

            1 => {

1150

                __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1151

1152

            2 => {

1153

                __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1154

1155

            3 => {

1156

                __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1157

1158

            4 => {

1159

                __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1160

1161

            5 => {

1162

                __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1163

1164

            6 => {

1165

                __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1166

1167

            7 => {

1168

                __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1169

1170

            8 => {

1171

                __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1172

1173

            9 => {

1174

                __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1175

1176

            10 => {

1177

                __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1178

1179

            11 => {

1180

                __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1181

1182

            12 => {

1183

                __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1184

1185

            13 => {

1186

                __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1187

1188

            14 => {

1189

                __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1190

1191

            15 => {

1192

                __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1193

1194

            16 => {

1195

                __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1196

1197

            17 => {

1198

                __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1199

1200

            18 => {

1201

                __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1202

1203

            19 => {

1204

                __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1205

1206

            20 => {

1207

                __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1208

1209

            21 => {

1210

                __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1211

1212

            22 => {

1213

                __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1214

1215

            23 => {

1216

                __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1217

1218

            24 => {

1219

                __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1220

1221

            25 => {

1222

                __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1223

1224

            26 => {

1225

                __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1226

1227

            27 => {

1228

                __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1229

1230

            28 => {

1231

                __reduce28(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1232

1233

            29 => {

1234

                __reduce29(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1235

1236

            30 => {

1237

                __reduce30(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1238

1239

            31 => {

1240

                __reduce31(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1241

1242

            32 => {

1243

                __reduce32(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1244

1245

            33 => {

1246

                __reduce33(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1247

1248

            34 => {

1249

                __reduce34(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1250

1251

            35 => {

1252

                __reduce35(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1253

1254

            36 => {

1255

                __reduce36(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1256

1257

            37 => {

1258

                __reduce37(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1259

1260

            38 => {

1261

                __reduce38(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1262

1263

            39 => {

1264

                __reduce39(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1265

1266

            40 => {

1267

                __reduce40(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1268

1269

            41 => {

1270

                __reduce41(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1271

1272

            42 => {

1273

                __reduce42(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1274

1275

            43 => {

1276

                __reduce43(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1277

1278

            44 => {

1279

                __reduce44(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1280

1281

            45 => {

1282

                __reduce45(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1283

1284

            46 => {

1285

                __reduce46(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1286

1287

            47 => {

1288

                __reduce47(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1289

1290

            48 => {

1291

                __reduce48(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1292

1293

            49 => {

1294

                __reduce49(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1295

1296

            50 => {

1297

                __reduce50(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1298

1299

            51 => {

1300

                __reduce51(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1301

1302

            52 => {

1303

                __reduce52(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1304

1305

            53 => {

1306

                __reduce53(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1307

1308

            54 => {

1309

                __reduce54(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1310

1311

            55 => {

1312

                __reduce55(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1313

1314

            56 => {

1315

                __reduce56(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1316

1317

            57 => {

1318

                __reduce57(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1319

1320

            58 => {

1321

                __reduce58(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1322

1323

            59 => {

1324

                __reduce59(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1325

1326

            60 => {

1327

                __reduce60(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1328

1329

            61 => {

1330

                __reduce61(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1331

1332

            62 => {

1333

                __reduce62(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1334

1335

            63 => {

1336

                __reduce63(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1337

1338

            64 => {

1339

                __reduce64(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1340

1341

            65 => {

1342

                __reduce65(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1343

1344

            66 => {

1345

                __reduce66(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1346

1347

            67 => {

1348

                __reduce67(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1349

1350

            68 => {

1351

                __reduce68(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1352

1353

            69 => {

1354

                __reduce69(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1355

1356

            70 => {

1357

                __reduce70(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1358

1359

            71 => {

1360

                __reduce71(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1361

1362

            72 => {

1363

                __reduce72(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1364

1365

            73 => {

1366

                __reduce73(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1367

1368

            74 => {

1369

                __reduce74(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1370

1371

            75 => {

1372

                __reduce75(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>)

1373

1374

            76 => {

1375

                // __Regex = Regex => ActionFn(0);

1376

                let __sym0 = __pop_Variant2(__symbols);

1377

                let __start = __sym0.0;

1378

                let __end = __sym0.2;

1379

                let __nt = super::__action0::<>(input, __sym0);

1380

                return Some(Ok(__nt));

1381

1382

            _ => panic!("invalid action code {}", __action)

1383

};

1384

        let __states_len = __states.len();

1385

        __states.truncate(__states_len - __pop_states);

1386

        let __state = *__states.last().unwrap();

1387

        let __next_state = __goto(__state, __nonterminal);

1388

        __states.push(__next_state);

1389

        None

1390

1391

    #[inline(never)]

1392

    fn __symbol_type_mismatch() -> ! {

1393

        panic!("symbol type mismatch")

1394

1395

    fn __pop_Variant2<

1396

>(

1397

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>

1398

    ) -> (usize, Hir, usize)

1399

1400

        match __symbols.pop() {

1401

            Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r),

1402

            _ => __symbol_type_mismatch()

1403

1404

1405

    fn __pop_Variant1<

1406

>(

1407

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>

1408

    ) -> (usize, Token, usize)

1409

1410

        match __symbols.pop() {

1411

            Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r),

1412

            _ => __symbol_type_mismatch()

1413

1414

1415

    fn __pop_Variant5<

1416

>(

1417

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>

1418

    ) -> (usize, alloc::vec::Vec<Hir>, usize)

1419

1420

        match __symbols.pop() {

1421

            Some((__l, __Symbol::Variant5(__v), __r)) => (__l, __v, __r),

1422

            _ => __symbol_type_mismatch()

1423

1424

1425

    fn __pop_Variant4<

1426

>(

1427

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>

1428

    ) -> (usize, alloc::vec::Vec<Token>, usize)

1429

1430

        match __symbols.pop() {

1431

            Some((__l, __Symbol::Variant4(__v), __r)) => (__l, __v, __r),

1432

            _ => __symbol_type_mismatch()

1433

1434

1435

    fn __pop_Variant3<

1436

>(

1437

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>

1438

    ) -> (usize, core::option::Option<lexer::Token>, usize)

1439

1440

        match __symbols.pop() {

1441

            Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r),

1442

            _ => __symbol_type_mismatch()

1443

1444

1445

    fn __pop_Variant0<

1446

>(

1447

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>

1448

    ) -> (usize, lexer::Token, usize)

1449

1450

        match __symbols.pop() {

1451

            Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r),

1452

            _ => __symbol_type_mismatch()

1453

1454

1455

    pub(crate) fn __reduce0<

1456

        'input,

1457

>(

1458

        input: &'input str,

1459

        __lookahead_start: Option<&usize>,

1460

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1461

        _: core::marker::PhantomData<(&'input ())>,

1462

    ) -> (usize, usize)

1463

1464

        // AnyChar = PIPE => ActionFn(46);

1465

        let __sym0 = __pop_Variant0(__symbols);

1466

        let __start = __sym0.0;

1467

        let __end = __sym0.2;

1468

        let __nt = super::__action46::<>(input, __sym0);

1469

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1470

        (1, 0)

1471

1472

    pub(crate) fn __reduce1<

1473

        'input,

1474

>(

1475

        input: &'input str,

1476

        __lookahead_start: Option<&usize>,

1477

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1478

        _: core::marker::PhantomData<(&'input ())>,

1479

    ) -> (usize, usize)

1480

1481

        // AnyChar = STAR => ActionFn(47);

1482

        let __sym0 = __pop_Variant0(__symbols);

1483

        let __start = __sym0.0;

1484

        let __end = __sym0.2;

1485

        let __nt = super::__action47::<>(input, __sym0);

1486

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1487

        (1, 0)

1488

1489

    pub(crate) fn __reduce2<

1490

        'input,

1491

>(

1492

        input: &'input str,

1493

        __lookahead_start: Option<&usize>,

1494

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1495

        _: core::marker::PhantomData<(&'input ())>,

1496

    ) -> (usize, usize)

1497

1498

        // AnyChar = PLUS => ActionFn(48);

1499

        let __sym0 = __pop_Variant0(__symbols);

1500

        let __start = __sym0.0;

1501

        let __end = __sym0.2;

1502

        let __nt = super::__action48::<>(input, __sym0);

1503

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1504

        (1, 0)

1505

1506

    pub(crate) fn __reduce3<

1507

        'input,

1508

>(

1509

        input: &'input str,

1510

        __lookahead_start: Option<&usize>,

1511

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1512

        _: core::marker::PhantomData<(&'input ())>,

1513

    ) -> (usize, usize)

1514

1515

        // AnyChar = QUESTION => ActionFn(49);

1516

        let __sym0 = __pop_Variant0(__symbols);

1517

        let __start = __sym0.0;

1518

        let __end = __sym0.2;

1519

        let __nt = super::__action49::<>(input, __sym0);

1520

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1521

        (1, 0)

1522

1523

    pub(crate) fn __reduce4<

1524

        'input,

1525

>(

1526

        input: &'input str,

1527

        __lookahead_start: Option<&usize>,

1528

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1529

        _: core::marker::PhantomData<(&'input ())>,

1530

    ) -> (usize, usize)

1531

1532

        // AnyChar = LPAREN => ActionFn(50);

1533

        let __sym0 = __pop_Variant0(__symbols);

1534

        let __start = __sym0.0;

1535

        let __end = __sym0.2;

1536

        let __nt = super::__action50::<>(input, __sym0);

1537

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1538

        (1, 0)

1539

1540

    pub(crate) fn __reduce5<

1541

        'input,

1542

>(

1543

        input: &'input str,

1544

        __lookahead_start: Option<&usize>,

1545

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1546

        _: core::marker::PhantomData<(&'input ())>,

1547

    ) -> (usize, usize)

1548

1549

        // AnyChar = RPAREN => ActionFn(51);

1550

        let __sym0 = __pop_Variant0(__symbols);

1551

        let __start = __sym0.0;

1552

        let __end = __sym0.2;

1553

        let __nt = super::__action51::<>(input, __sym0);

1554

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1555

        (1, 0)

1556

1557

    pub(crate) fn __reduce6<

1558

        'input,

1559

>(

1560

        input: &'input str,

1561

        __lookahead_start: Option<&usize>,

1562

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1563

        _: core::marker::PhantomData<(&'input ())>,

1564

    ) -> (usize, usize)

1565

1566

        // AnyChar = DOT => ActionFn(52);

1567

        let __sym0 = __pop_Variant0(__symbols);

1568

        let __start = __sym0.0;

1569

        let __end = __sym0.2;

1570

        let __nt = super::__action52::<>(input, __sym0);

1571

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1572

        (1, 0)

1573

1574

    pub(crate) fn __reduce7<

1575

        'input,

1576

>(

1577

        input: &'input str,

1578

        __lookahead_start: Option<&usize>,

1579

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1580

        _: core::marker::PhantomData<(&'input ())>,

1581

    ) -> (usize, usize)

1582

1583

        // AnyChar = CARET => ActionFn(53);

1584

        let __sym0 = __pop_Variant0(__symbols);

1585

        let __start = __sym0.0;

1586

        let __end = __sym0.2;

1587

        let __nt = super::__action53::<>(input, __sym0);

1588

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1589

        (1, 0)

1590

1591

    pub(crate) fn __reduce8<

1592

        'input,

1593

>(

1594

        input: &'input str,

1595

        __lookahead_start: Option<&usize>,

1596

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1597

        _: core::marker::PhantomData<(&'input ())>,

1598

    ) -> (usize, usize)

1599

1600

        // AnyChar = DOLLAR => ActionFn(54);

1601

        let __sym0 = __pop_Variant0(__symbols);

1602

        let __start = __sym0.0;

1603

        let __end = __sym0.2;

1604

        let __nt = super::__action54::<>(input, __sym0);

1605

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1606

        (1, 0)

1607

1608

    pub(crate) fn __reduce9<

1609

        'input,

1610

>(

1611

        input: &'input str,

1612

        __lookahead_start: Option<&usize>,

1613

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1614

        _: core::marker::PhantomData<(&'input ())>,

1615

    ) -> (usize, usize)

1616

1617

        // AnyChar = BACKSLASH => ActionFn(55);

1618

        let __sym0 = __pop_Variant0(__symbols);

1619

        let __start = __sym0.0;

1620

        let __end = __sym0.2;

1621

        let __nt = super::__action55::<>(input, __sym0);

1622

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1623

        (1, 0)

1624

1625

    pub(crate) fn __reduce10<

1626

        'input,

1627

>(

1628

        input: &'input str,

1629

        __lookahead_start: Option<&usize>,

1630

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1631

        _: core::marker::PhantomData<(&'input ())>,

1632

    ) -> (usize, usize)

1633

1634

        // AnyChar = LBRACKET => ActionFn(56);

1635

        let __sym0 = __pop_Variant0(__symbols);

1636

        let __start = __sym0.0;

1637

        let __end = __sym0.2;

1638

        let __nt = super::__action56::<>(input, __sym0);

1639

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1640

        (1, 0)

1641

1642

    pub(crate) fn __reduce11<

1643

        'input,

1644

>(

1645

        input: &'input str,

1646

        __lookahead_start: Option<&usize>,

1647

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1648

        _: core::marker::PhantomData<(&'input ())>,

1649

    ) -> (usize, usize)

1650

1651

        // AnyChar = RBRACKET => ActionFn(57);

1652

        let __sym0 = __pop_Variant0(__symbols);

1653

        let __start = __sym0.0;

1654

        let __end = __sym0.2;

1655

        let __nt = super::__action57::<>(input, __sym0);

1656

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1657

        (1, 0)

1658

1659

    pub(crate) fn __reduce12<

1660

        'input,

1661

>(

1662

        input: &'input str,

1663

        __lookahead_start: Option<&usize>,

1664

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1665

        _: core::marker::PhantomData<(&'input ())>,

1666

    ) -> (usize, usize)

1667

1668

        // AnyChar = DASH => ActionFn(58);

1669

        let __sym0 = __pop_Variant0(__symbols);

1670

        let __start = __sym0.0;

1671

        let __end = __sym0.2;

1672

        let __nt = super::__action58::<>(input, __sym0);

1673

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1674

        (1, 0)

1675

1676

    pub(crate) fn __reduce13<

1677

        'input,

1678

>(

1679

        input: &'input str,

1680

        __lookahead_start: Option<&usize>,

1681

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1682

        _: core::marker::PhantomData<(&'input ())>,

1683

    ) -> (usize, usize)

1684

1685

        // AnyChar = OTHER => ActionFn(59);

1686

        let __sym0 = __pop_Variant0(__symbols);

1687

        let __start = __sym0.0;

1688

        let __end = __sym0.2;

1689

        let __nt = super::__action59::<>(input, __sym0);

1690

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1691

        (1, 0)

1692

1693

    pub(crate) fn __reduce14<

1694

        'input,

1695

>(

1696

        input: &'input str,

1697

        __lookahead_start: Option<&usize>,

1698

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1699

        _: core::marker::PhantomData<(&'input ())>,

1700

    ) -> (usize, usize)

1701

1702

        // Atom = LPAREN, Regex, RPAREN => ActionFn(10);

1703

        assert!(__symbols.len() >= 3);

1704

        let __sym2 = __pop_Variant0(__symbols);

1705

        let __sym1 = __pop_Variant2(__symbols);

1706

        let __sym0 = __pop_Variant0(__symbols);

1707

        let __start = __sym0.0;

1708

        let __end = __sym2.2;

1709

        let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2);

1710

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1711

        (3, 1)

1712

1713

    pub(crate) fn __reduce15<

1714

        'input,

1715

>(

1716

        input: &'input str,

1717

        __lookahead_start: Option<&usize>,

1718

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1719

        _: core::marker::PhantomData<(&'input ())>,

1720

    ) -> (usize, usize)

1721

1722

        // Atom = Range => ActionFn(11);

1723

        let __sym0 = __pop_Variant2(__symbols);

1724

        let __start = __sym0.0;

1725

        let __end = __sym0.2;

1726

        let __nt = super::__action11::<>(input, __sym0);

1727

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1728

        (1, 1)

1729

1730

    pub(crate) fn __reduce16<

1731

        'input,

1732

>(

1733

        input: &'input str,

1734

        __lookahead_start: Option<&usize>,

1735

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1736

        _: core::marker::PhantomData<(&'input ())>,

1737

    ) -> (usize, usize)

1738

1739

        // Atom = DOT => ActionFn(12);

1740

        let __sym0 = __pop_Variant0(__symbols);

1741

        let __start = __sym0.0;

1742

        let __end = __sym0.2;

1743

        let __nt = super::__action12::<>(input, __sym0);

1744

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1745

        (1, 1)

1746

1747

    pub(crate) fn __reduce17<

1748

        'input,

1749

>(

1750

        input: &'input str,

1751

        __lookahead_start: Option<&usize>,

1752

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1753

        _: core::marker::PhantomData<(&'input ())>,

1754

    ) -> (usize, usize)

1755

1756

        // Atom = CARET => ActionFn(13);

1757

        let __sym0 = __pop_Variant0(__symbols);

1758

        let __start = __sym0.0;

1759

        let __end = __sym0.2;

1760

        let __nt = super::__action13::<>(input, __sym0);

1761

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1762

        (1, 1)

1763

1764

    pub(crate) fn __reduce18<

1765

        'input,

1766

>(

1767

        input: &'input str,

1768

        __lookahead_start: Option<&usize>,

1769

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1770

        _: core::marker::PhantomData<(&'input ())>,

1771

    ) -> (usize, usize)

1772

1773

        // Atom = DOLLAR => ActionFn(14);

1774

        let __sym0 = __pop_Variant0(__symbols);

1775

        let __start = __sym0.0;

1776

        let __end = __sym0.2;

1777

        let __nt = super::__action14::<>(input, __sym0);

1778

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1779

        (1, 1)

1780

1781

    pub(crate) fn __reduce19<

1782

        'input,

1783

>(

1784

        input: &'input str,

1785

        __lookahead_start: Option<&usize>,

1786

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1787

        _: core::marker::PhantomData<(&'input ())>,

1788

    ) -> (usize, usize)

1789

1790

        // Atom = BACKSLASH, AnyChar => ActionFn(15);

1791

        assert!(__symbols.len() >= 2);

1792

        let __sym1 = __pop_Variant1(__symbols);

1793

        let __sym0 = __pop_Variant0(__symbols);

1794

        let __start = __sym0.0;

1795

        let __end = __sym1.2;

1796

        let __nt = super::__action15::<>(input, __sym0, __sym1);

1797

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1798

        (2, 1)

1799

1800

    pub(crate) fn __reduce20<

1801

        'input,

1802

>(

1803

        input: &'input str,

1804

        __lookahead_start: Option<&usize>,

1805

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1806

        _: core::marker::PhantomData<(&'input ())>,

1807

    ) -> (usize, usize)

1808

1809

        // Atom = DASH => ActionFn(16);

1810

        let __sym0 = __pop_Variant0(__symbols);

1811

        let __start = __sym0.0;

1812

        let __end = __sym0.2;

1813

        let __nt = super::__action16::<>(input, __sym0);

1814

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1815

        (1, 1)

1816

1817

    pub(crate) fn __reduce21<

1818

        'input,

1819

>(

1820

        input: &'input str,

1821

        __lookahead_start: Option<&usize>,

1822

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1823

        _: core::marker::PhantomData<(&'input ())>,

1824

    ) -> (usize, usize)

1825

1826

        // Atom = OTHER => ActionFn(17);

1827

        let __sym0 = __pop_Variant0(__symbols);

1828

        let __start = __sym0.0;

1829

        let __end = __sym0.2;

1830

        let __nt = super::__action17::<>(input, __sym0);

1831

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1832

        (1, 1)

1833

1834

    pub(crate) fn __reduce22<

1835

        'input,

1836

>(

1837

        input: &'input str,

1838

        __lookahead_start: Option<&usize>,

1839

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1840

        _: core::marker::PhantomData<(&'input ())>,

1841

    ) -> (usize, usize)

1842

1843

        // Branch =  => ActionFn(4);

1844

        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();

1845

        let __end = __start.clone();

1846

        let __nt = super::__action4::<>(input, &__start, &__end);

1847

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1848

        (0, 2)

1849

1850

    pub(crate) fn __reduce23<

1851

        'input,

1852

>(

1853

        input: &'input str,

1854

        __lookahead_start: Option<&usize>,

1855

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1856

        _: core::marker::PhantomData<(&'input ())>,

1857

    ) -> (usize, usize)

1858

1859

        // Branch = Piece+ => ActionFn(5);

1860

        let __sym0 = __pop_Variant5(__symbols);

1861

        let __start = __sym0.0;

1862

        let __end = __sym0.2;

1863

        let __nt = super::__action5::<>(input, __sym0);

1864

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1865

        (1, 2)

1866

1867

    pub(crate) fn __reduce24<

1868

        'input,

1869

>(

1870

        input: &'input str,

1871

        __lookahead_start: Option<&usize>,

1872

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1873

        _: core::marker::PhantomData<(&'input ())>,

1874

    ) -> (usize, usize)

1875

1876

        // CARET? = CARET => ActionFn(64);

1877

        let __sym0 = __pop_Variant0(__symbols);

1878

        let __start = __sym0.0;

1879

        let __end = __sym0.2;

1880

        let __nt = super::__action64::<>(input, __sym0);

1881

        __symbols.push((__start, __Symbol::Variant3(__nt), __end));

1882

        (1, 3)

1883

1884

    pub(crate) fn __reduce25<

1885

        'input,

1886

>(

1887

        input: &'input str,

1888

        __lookahead_start: Option<&usize>,

1889

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1890

        _: core::marker::PhantomData<(&'input ())>,

1891

    ) -> (usize, usize)

1892

1893

        // CARET? =  => ActionFn(65);

1894

        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();

1895

        let __end = __start.clone();

1896

        let __nt = super::__action65::<>(input, &__start, &__end);

1897

        __symbols.push((__start, __Symbol::Variant3(__nt), __end));

1898

        (0, 3)

1899

1900

    pub(crate) fn __reduce26<

1901

        'input,

1902

>(

1903

        input: &'input str,

1904

        __lookahead_start: Option<&usize>,

1905

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1906

        _: core::marker::PhantomData<(&'input ())>,

1907

    ) -> (usize, usize)

1908

1909

        // LBranch = Branch => ActionFn(2);

1910

        let __sym0 = __pop_Variant2(__symbols);

1911

        let __start = __sym0.0;

1912

        let __end = __sym0.2;

1913

        let __nt = super::__action2::<>(input, __sym0);

1914

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

1915

        (1, 4)

1916

1917

    pub(crate) fn __reduce27<

1918

        'input,

1919

>(

1920

        input: &'input str,

1921

        __lookahead_start: Option<&usize>,

1922

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1923

        _: core::marker::PhantomData<(&'input ())>,

1924

    ) -> (usize, usize)

1925

1926

        // NotCaretNotRBracket = PIPE => ActionFn(34);

1927

        let __sym0 = __pop_Variant0(__symbols);

1928

        let __start = __sym0.0;

1929

        let __end = __sym0.2;

1930

        let __nt = super::__action34::<>(input, __sym0);

1931

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1932

        (1, 5)

1933

1934

    pub(crate) fn __reduce28<

1935

        'input,

1936

>(

1937

        input: &'input str,

1938

        __lookahead_start: Option<&usize>,

1939

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1940

        _: core::marker::PhantomData<(&'input ())>,

1941

    ) -> (usize, usize)

1942

1943

        // NotCaretNotRBracket = STAR => ActionFn(35);

1944

        let __sym0 = __pop_Variant0(__symbols);

1945

        let __start = __sym0.0;

1946

        let __end = __sym0.2;

1947

        let __nt = super::__action35::<>(input, __sym0);

1948

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1949

        (1, 5)

1950

1951

    pub(crate) fn __reduce29<

1952

        'input,

1953

>(

1954

        input: &'input str,

1955

        __lookahead_start: Option<&usize>,

1956

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1957

        _: core::marker::PhantomData<(&'input ())>,

1958

    ) -> (usize, usize)

1959

1960

        // NotCaretNotRBracket = PLUS => ActionFn(36);

1961

        let __sym0 = __pop_Variant0(__symbols);

1962

        let __start = __sym0.0;

1963

        let __end = __sym0.2;

1964

        let __nt = super::__action36::<>(input, __sym0);

1965

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1966

        (1, 5)

1967

1968

    pub(crate) fn __reduce30<

1969

        'input,

1970

>(

1971

        input: &'input str,

1972

        __lookahead_start: Option<&usize>,

1973

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1974

        _: core::marker::PhantomData<(&'input ())>,

1975

    ) -> (usize, usize)

1976

1977

        // NotCaretNotRBracket = QUESTION => ActionFn(37);

1978

        let __sym0 = __pop_Variant0(__symbols);

1979

        let __start = __sym0.0;

1980

        let __end = __sym0.2;

1981

        let __nt = super::__action37::<>(input, __sym0);

1982

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

1983

        (1, 5)

1984

1985

    pub(crate) fn __reduce31<

1986

        'input,

1987

>(

1988

        input: &'input str,

1989

        __lookahead_start: Option<&usize>,

1990

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

1991

        _: core::marker::PhantomData<(&'input ())>,

1992

    ) -> (usize, usize)

1993

1994

        // NotCaretNotRBracket = LPAREN => ActionFn(38);

1995

        let __sym0 = __pop_Variant0(__symbols);

1996

        let __start = __sym0.0;

1997

        let __end = __sym0.2;

1998

        let __nt = super::__action38::<>(input, __sym0);

1999

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2000

        (1, 5)

2001

2002

    pub(crate) fn __reduce32<

2003

        'input,

2004

>(

2005

        input: &'input str,

2006

        __lookahead_start: Option<&usize>,

2007

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2008

        _: core::marker::PhantomData<(&'input ())>,

2009

    ) -> (usize, usize)

2010

2011

        // NotCaretNotRBracket = RPAREN => ActionFn(39);

2012

        let __sym0 = __pop_Variant0(__symbols);

2013

        let __start = __sym0.0;

2014

        let __end = __sym0.2;

2015

        let __nt = super::__action39::<>(input, __sym0);

2016

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2017

        (1, 5)

2018

2019

    pub(crate) fn __reduce33<

2020

        'input,

2021

>(

2022

        input: &'input str,

2023

        __lookahead_start: Option<&usize>,

2024

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2025

        _: core::marker::PhantomData<(&'input ())>,

2026

    ) -> (usize, usize)

2027

2028

        // NotCaretNotRBracket = DOT => ActionFn(40);

2029

        let __sym0 = __pop_Variant0(__symbols);

2030

        let __start = __sym0.0;

2031

        let __end = __sym0.2;

2032

        let __nt = super::__action40::<>(input, __sym0);

2033

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2034

        (1, 5)

2035

2036

    pub(crate) fn __reduce34<

2037

        'input,

2038

>(

2039

        input: &'input str,

2040

        __lookahead_start: Option<&usize>,

2041

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2042

        _: core::marker::PhantomData<(&'input ())>,

2043

    ) -> (usize, usize)

2044

2045

        // NotCaretNotRBracket = DOLLAR => ActionFn(41);

2046

        let __sym0 = __pop_Variant0(__symbols);

2047

        let __start = __sym0.0;

2048

        let __end = __sym0.2;

2049

        let __nt = super::__action41::<>(input, __sym0);

2050

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2051

        (1, 5)

2052

2053

    pub(crate) fn __reduce35<

2054

        'input,

2055

>(

2056

        input: &'input str,

2057

        __lookahead_start: Option<&usize>,

2058

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2059

        _: core::marker::PhantomData<(&'input ())>,

2060

    ) -> (usize, usize)

2061

2062

        // NotCaretNotRBracket = BACKSLASH => ActionFn(42);

2063

        let __sym0 = __pop_Variant0(__symbols);

2064

        let __start = __sym0.0;

2065

        let __end = __sym0.2;

2066

        let __nt = super::__action42::<>(input, __sym0);

2067

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2068

        (1, 5)

2069

2070

    pub(crate) fn __reduce36<

2071

        'input,

2072

>(

2073

        input: &'input str,

2074

        __lookahead_start: Option<&usize>,

2075

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2076

        _: core::marker::PhantomData<(&'input ())>,

2077

    ) -> (usize, usize)

2078

2079

        // NotCaretNotRBracket = LBRACKET => ActionFn(43);

2080

        let __sym0 = __pop_Variant0(__symbols);

2081

        let __start = __sym0.0;

2082

        let __end = __sym0.2;

2083

        let __nt = super::__action43::<>(input, __sym0);

2084

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2085

        (1, 5)

2086

2087

    pub(crate) fn __reduce37<

2088

        'input,

2089

>(

2090

        input: &'input str,

2091

        __lookahead_start: Option<&usize>,

2092

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2093

        _: core::marker::PhantomData<(&'input ())>,

2094

    ) -> (usize, usize)

2095

2096

        // NotCaretNotRBracket = DASH => ActionFn(44);

2097

        let __sym0 = __pop_Variant0(__symbols);

2098

        let __start = __sym0.0;

2099

        let __end = __sym0.2;

2100

        let __nt = super::__action44::<>(input, __sym0);

2101

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2102

        (1, 5)

2103

2104

    pub(crate) fn __reduce38<

2105

        'input,

2106

>(

2107

        input: &'input str,

2108

        __lookahead_start: Option<&usize>,

2109

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2110

        _: core::marker::PhantomData<(&'input ())>,

2111

    ) -> (usize, usize)

2112

2113

        // NotCaretNotRBracket = OTHER => ActionFn(45);

2114

        let __sym0 = __pop_Variant0(__symbols);

2115

        let __start = __sym0.0;

2116

        let __end = __sym0.2;

2117

        let __nt = super::__action45::<>(input, __sym0);

2118

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2119

        (1, 5)

2120

2121

    pub(crate) fn __reduce39<

2122

        'input,

2123

>(

2124

        input: &'input str,

2125

        __lookahead_start: Option<&usize>,

2126

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2127

        _: core::marker::PhantomData<(&'input ())>,

2128

    ) -> (usize, usize)

2129

2130

        // NotRBracket = PIPE => ActionFn(21);

2131

        let __sym0 = __pop_Variant0(__symbols);

2132

        let __start = __sym0.0;

2133

        let __end = __sym0.2;

2134

        let __nt = super::__action21::<>(input, __sym0);

2135

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2136

        (1, 6)

2137

2138

    pub(crate) fn __reduce40<

2139

        'input,

2140

>(

2141

        input: &'input str,

2142

        __lookahead_start: Option<&usize>,

2143

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2144

        _: core::marker::PhantomData<(&'input ())>,

2145

    ) -> (usize, usize)

2146

2147

        // NotRBracket = STAR => ActionFn(22);

2148

        let __sym0 = __pop_Variant0(__symbols);

2149

        let __start = __sym0.0;

2150

        let __end = __sym0.2;

2151

        let __nt = super::__action22::<>(input, __sym0);

2152

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2153

        (1, 6)

2154

2155

    pub(crate) fn __reduce41<

2156

        'input,

2157

>(

2158

        input: &'input str,

2159

        __lookahead_start: Option<&usize>,

2160

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2161

        _: core::marker::PhantomData<(&'input ())>,

2162

    ) -> (usize, usize)

2163

2164

        // NotRBracket = PLUS => ActionFn(23);

2165

        let __sym0 = __pop_Variant0(__symbols);

2166

        let __start = __sym0.0;

2167

        let __end = __sym0.2;

2168

        let __nt = super::__action23::<>(input, __sym0);

2169

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2170

        (1, 6)

2171

2172

    pub(crate) fn __reduce42<

2173

        'input,

2174

>(

2175

        input: &'input str,

2176

        __lookahead_start: Option<&usize>,

2177

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2178

        _: core::marker::PhantomData<(&'input ())>,

2179

    ) -> (usize, usize)

2180

2181

        // NotRBracket = QUESTION => ActionFn(24);

2182

        let __sym0 = __pop_Variant0(__symbols);

2183

        let __start = __sym0.0;

2184

        let __end = __sym0.2;

2185

        let __nt = super::__action24::<>(input, __sym0);

2186

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2187

        (1, 6)

2188

2189

    pub(crate) fn __reduce43<

2190

        'input,

2191

>(

2192

        input: &'input str,

2193

        __lookahead_start: Option<&usize>,

2194

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2195

        _: core::marker::PhantomData<(&'input ())>,

2196

    ) -> (usize, usize)

2197

2198

        // NotRBracket = LPAREN => ActionFn(25);

2199

        let __sym0 = __pop_Variant0(__symbols);

2200

        let __start = __sym0.0;

2201

        let __end = __sym0.2;

2202

        let __nt = super::__action25::<>(input, __sym0);

2203

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2204

        (1, 6)

2205

2206

    pub(crate) fn __reduce44<

2207

        'input,

2208

>(

2209

        input: &'input str,

2210

        __lookahead_start: Option<&usize>,

2211

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2212

        _: core::marker::PhantomData<(&'input ())>,

2213

    ) -> (usize, usize)

2214

2215

        // NotRBracket = RPAREN => ActionFn(26);

2216

        let __sym0 = __pop_Variant0(__symbols);

2217

        let __start = __sym0.0;

2218

        let __end = __sym0.2;

2219

        let __nt = super::__action26::<>(input, __sym0);

2220

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2221

        (1, 6)

2222

2223

    pub(crate) fn __reduce45<

2224

        'input,

2225

>(

2226

        input: &'input str,

2227

        __lookahead_start: Option<&usize>,

2228

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2229

        _: core::marker::PhantomData<(&'input ())>,

2230

    ) -> (usize, usize)

2231

2232

        // NotRBracket = DOT => ActionFn(27);

2233

        let __sym0 = __pop_Variant0(__symbols);

2234

        let __start = __sym0.0;

2235

        let __end = __sym0.2;

2236

        let __nt = super::__action27::<>(input, __sym0);

2237

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2238

        (1, 6)

2239

2240

    pub(crate) fn __reduce46<

2241

        'input,

2242

>(

2243

        input: &'input str,

2244

        __lookahead_start: Option<&usize>,

2245

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2246

        _: core::marker::PhantomData<(&'input ())>,

2247

    ) -> (usize, usize)

2248

2249

        // NotRBracket = CARET => ActionFn(28);

2250

        let __sym0 = __pop_Variant0(__symbols);

2251

        let __start = __sym0.0;

2252

        let __end = __sym0.2;

2253

        let __nt = super::__action28::<>(input, __sym0);

2254

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2255

        (1, 6)

2256

2257

    pub(crate) fn __reduce47<

2258

        'input,

2259

>(

2260

        input: &'input str,

2261

        __lookahead_start: Option<&usize>,

2262

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2263

        _: core::marker::PhantomData<(&'input ())>,

2264

    ) -> (usize, usize)

2265

2266

        // NotRBracket = DOLLAR => ActionFn(29);

2267

        let __sym0 = __pop_Variant0(__symbols);

2268

        let __start = __sym0.0;

2269

        let __end = __sym0.2;

2270

        let __nt = super::__action29::<>(input, __sym0);

2271

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2272

        (1, 6)

2273

2274

    pub(crate) fn __reduce48<

2275

        'input,

2276

>(

2277

        input: &'input str,

2278

        __lookahead_start: Option<&usize>,

2279

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2280

        _: core::marker::PhantomData<(&'input ())>,

2281

    ) -> (usize, usize)

2282

2283

        // NotRBracket = BACKSLASH => ActionFn(30);

2284

        let __sym0 = __pop_Variant0(__symbols);

2285

        let __start = __sym0.0;

2286

        let __end = __sym0.2;

2287

        let __nt = super::__action30::<>(input, __sym0);

2288

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2289

        (1, 6)

2290

2291

    pub(crate) fn __reduce49<

2292

        'input,

2293

>(

2294

        input: &'input str,

2295

        __lookahead_start: Option<&usize>,

2296

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2297

        _: core::marker::PhantomData<(&'input ())>,

2298

    ) -> (usize, usize)

2299

2300

        // NotRBracket = LBRACKET => ActionFn(31);

2301

        let __sym0 = __pop_Variant0(__symbols);

2302

        let __start = __sym0.0;

2303

        let __end = __sym0.2;

2304

        let __nt = super::__action31::<>(input, __sym0);

2305

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2306

        (1, 6)

2307

2308

    pub(crate) fn __reduce50<

2309

        'input,

2310

>(

2311

        input: &'input str,

2312

        __lookahead_start: Option<&usize>,

2313

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2314

        _: core::marker::PhantomData<(&'input ())>,

2315

    ) -> (usize, usize)

2316

2317

        // NotRBracket = DASH => ActionFn(32);

2318

        let __sym0 = __pop_Variant0(__symbols);

2319

        let __start = __sym0.0;

2320

        let __end = __sym0.2;

2321

        let __nt = super::__action32::<>(input, __sym0);

2322

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2323

        (1, 6)

2324

2325

    pub(crate) fn __reduce51<

2326

        'input,

2327

>(

2328

        input: &'input str,

2329

        __lookahead_start: Option<&usize>,

2330

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2331

        _: core::marker::PhantomData<(&'input ())>,

2332

    ) -> (usize, usize)

2333

2334

        // NotRBracket = OTHER => ActionFn(33);

2335

        let __sym0 = __pop_Variant0(__symbols);

2336

        let __start = __sym0.0;

2337

        let __end = __sym0.2;

2338

        let __nt = super::__action33::<>(input, __sym0);

2339

        __symbols.push((__start, __Symbol::Variant1(__nt), __end));

2340

        (1, 6)

2341

2342

    pub(crate) fn __reduce52<

2343

        'input,

2344

>(

2345

        input: &'input str,

2346

        __lookahead_start: Option<&usize>,

2347

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2348

        _: core::marker::PhantomData<(&'input ())>,

2349

    ) -> (usize, usize)

2350

2351

        // NotRBracket* =  => ActionFn(62);

2352

        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();

2353

        let __end = __start.clone();

2354

        let __nt = super::__action62::<>(input, &__start, &__end);

2355

        __symbols.push((__start, __Symbol::Variant4(__nt), __end));

2356

        (0, 7)

2357

2358

    pub(crate) fn __reduce53<

2359

        'input,

2360

>(

2361

        input: &'input str,

2362

        __lookahead_start: Option<&usize>,

2363

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2364

        _: core::marker::PhantomData<(&'input ())>,

2365

    ) -> (usize, usize)

2366

2367

        // NotRBracket* = NotRBracket+ => ActionFn(63);

2368

        let __sym0 = __pop_Variant4(__symbols);

2369

        let __start = __sym0.0;

2370

        let __end = __sym0.2;

2371

        let __nt = super::__action63::<>(input, __sym0);

2372

        __symbols.push((__start, __Symbol::Variant4(__nt), __end));

2373

        (1, 7)

2374

2375

    pub(crate) fn __reduce54<

2376

        'input,

2377

>(

2378

        input: &'input str,

2379

        __lookahead_start: Option<&usize>,

2380

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2381

        _: core::marker::PhantomData<(&'input ())>,

2382

    ) -> (usize, usize)

2383

2384

        // NotRBracket+ = NotRBracket => ActionFn(60);

2385

        let __sym0 = __pop_Variant1(__symbols);

2386

        let __start = __sym0.0;

2387

        let __end = __sym0.2;

2388

        let __nt = super::__action60::<>(input, __sym0);

2389

        __symbols.push((__start, __Symbol::Variant4(__nt), __end));

2390

        (1, 8)

2391

2392

    pub(crate) fn __reduce55<

2393

        'input,

2394

>(

2395

        input: &'input str,

2396

        __lookahead_start: Option<&usize>,

2397

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2398

        _: core::marker::PhantomData<(&'input ())>,

2399

    ) -> (usize, usize)

2400

2401

        // NotRBracket+ = NotRBracket+, NotRBracket => ActionFn(61);

2402

        assert!(__symbols.len() >= 2);

2403

        let __sym1 = __pop_Variant1(__symbols);

2404

        let __sym0 = __pop_Variant4(__symbols);

2405

        let __start = __sym0.0;

2406

        let __end = __sym1.2;

2407

        let __nt = super::__action61::<>(input, __sym0, __sym1);

2408

        __symbols.push((__start, __Symbol::Variant4(__nt), __end));

2409

        (2, 8)

2410

2411

    pub(crate) fn __reduce56<

2412

        'input,

2413

>(

2414

        input: &'input str,

2415

        __lookahead_start: Option<&usize>,

2416

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2417

        _: core::marker::PhantomData<(&'input ())>,

2418

    ) -> (usize, usize)

2419

2420

        // Piece = Atom => ActionFn(6);

2421

        let __sym0 = __pop_Variant2(__symbols);

2422

        let __start = __sym0.0;

2423

        let __end = __sym0.2;

2424

        let __nt = super::__action6::<>(input, __sym0);

2425

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2426

        (1, 9)

2427

2428

    pub(crate) fn __reduce57<

2429

        'input,

2430

>(

2431

        input: &'input str,

2432

        __lookahead_start: Option<&usize>,

2433

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2434

        _: core::marker::PhantomData<(&'input ())>,

2435

    ) -> (usize, usize)

2436

2437

        // Piece = Atom, STAR => ActionFn(7);

2438

        assert!(__symbols.len() >= 2);

2439

        let __sym1 = __pop_Variant0(__symbols);

2440

        let __sym0 = __pop_Variant2(__symbols);

2441

        let __start = __sym0.0;

2442

        let __end = __sym1.2;

2443

        let __nt = super::__action7::<>(input, __sym0, __sym1);

2444

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2445

        (2, 9)

2446

2447

    pub(crate) fn __reduce58<

2448

        'input,

2449

>(

2450

        input: &'input str,

2451

        __lookahead_start: Option<&usize>,

2452

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2453

        _: core::marker::PhantomData<(&'input ())>,

2454

    ) -> (usize, usize)

2455

2456

        // Piece = Atom, PLUS => ActionFn(8);

2457

        assert!(__symbols.len() >= 2);

2458

        let __sym1 = __pop_Variant0(__symbols);

2459

        let __sym0 = __pop_Variant2(__symbols);

2460

        let __start = __sym0.0;

2461

        let __end = __sym1.2;

2462

        let __nt = super::__action8::<>(input, __sym0, __sym1);

2463

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2464

        (2, 9)

2465

2466

    pub(crate) fn __reduce59<

2467

        'input,

2468

>(

2469

        input: &'input str,

2470

        __lookahead_start: Option<&usize>,

2471

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2472

        _: core::marker::PhantomData<(&'input ())>,

2473

    ) -> (usize, usize)

2474

2475

        // Piece = Atom, QUESTION => ActionFn(9);

2476

        assert!(__symbols.len() >= 2);

2477

        let __sym1 = __pop_Variant0(__symbols);

2478

        let __sym0 = __pop_Variant2(__symbols);

2479

        let __start = __sym0.0;

2480

        let __end = __sym1.2;

2481

        let __nt = super::__action9::<>(input, __sym0, __sym1);

2482

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2483

        (2, 9)

2484

2485

    pub(crate) fn __reduce60<

2486

        'input,

2487

>(

2488

        input: &'input str,

2489

        __lookahead_start: Option<&usize>,

2490

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2491

        _: core::marker::PhantomData<(&'input ())>,

2492

    ) -> (usize, usize)

2493

2494

        // Piece+ = Piece => ActionFn(66);

2495

        let __sym0 = __pop_Variant2(__symbols);

2496

        let __start = __sym0.0;

2497

        let __end = __sym0.2;

2498

        let __nt = super::__action66::<>(input, __sym0);

2499

        __symbols.push((__start, __Symbol::Variant5(__nt), __end));

2500

        (1, 10)

2501

2502

    pub(crate) fn __reduce61<

2503

        'input,

2504

>(

2505

        input: &'input str,

2506

        __lookahead_start: Option<&usize>,

2507

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2508

        _: core::marker::PhantomData<(&'input ())>,

2509

    ) -> (usize, usize)

2510

2511

        // Piece+ = Piece+, Piece => ActionFn(67);

2512

        assert!(__symbols.len() >= 2);

2513

        let __sym1 = __pop_Variant2(__symbols);

2514

        let __sym0 = __pop_Variant5(__symbols);

2515

        let __start = __sym0.0;

2516

        let __end = __sym1.2;

2517

        let __nt = super::__action67::<>(input, __sym0, __sym1);

2518

        __symbols.push((__start, __Symbol::Variant5(__nt), __end));

2519

        (2, 10)

2520

2521

    pub(crate) fn __reduce62<

2522

        'input,

2523

>(

2524

        input: &'input str,

2525

        __lookahead_start: Option<&usize>,

2526

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2527

        _: core::marker::PhantomData<(&'input ())>,

2528

    ) -> (usize, usize)

2529

2530

        // RBranch = PIPE, Branch => ActionFn(3);

2531

        assert!(__symbols.len() >= 2);

2532

        let __sym1 = __pop_Variant2(__symbols);

2533

        let __sym0 = __pop_Variant0(__symbols);

2534

        let __start = __sym0.0;

2535

        let __end = __sym1.2;

2536

        let __nt = super::__action3::<>(input, __sym0, __sym1);

2537

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2538

        (2, 11)

2539

2540

    pub(crate) fn __reduce63<

2541

        'input,

2542

>(

2543

        input: &'input str,

2544

        __lookahead_start: Option<&usize>,

2545

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2546

        _: core::marker::PhantomData<(&'input ())>,

2547

    ) -> (usize, usize)

2548

2549

        // RBranch* =  => ActionFn(68);

2550

        let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default();

2551

        let __end = __start.clone();

2552

        let __nt = super::__action68::<>(input, &__start, &__end);

2553

        __symbols.push((__start, __Symbol::Variant5(__nt), __end));

2554

        (0, 12)

2555

2556

    pub(crate) fn __reduce64<

2557

        'input,

2558

>(

2559

        input: &'input str,

2560

        __lookahead_start: Option<&usize>,

2561

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2562

        _: core::marker::PhantomData<(&'input ())>,

2563

    ) -> (usize, usize)

2564

2565

        // RBranch* = RBranch+ => ActionFn(69);

2566

        let __sym0 = __pop_Variant5(__symbols);

2567

        let __start = __sym0.0;

2568

        let __end = __sym0.2;

2569

        let __nt = super::__action69::<>(input, __sym0);

2570

        __symbols.push((__start, __Symbol::Variant5(__nt), __end));

2571

        (1, 12)

2572

2573

    pub(crate) fn __reduce65<

2574

        'input,

2575

>(

2576

        input: &'input str,

2577

        __lookahead_start: Option<&usize>,

2578

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2579

        _: core::marker::PhantomData<(&'input ())>,

2580

    ) -> (usize, usize)

2581

2582

        // RBranch+ = RBranch => ActionFn(70);

2583

        let __sym0 = __pop_Variant2(__symbols);

2584

        let __start = __sym0.0;

2585

        let __end = __sym0.2;

2586

        let __nt = super::__action70::<>(input, __sym0);

2587

        __symbols.push((__start, __Symbol::Variant5(__nt), __end));

2588

        (1, 13)

2589

2590

    pub(crate) fn __reduce66<

2591

        'input,

2592

>(

2593

        input: &'input str,

2594

        __lookahead_start: Option<&usize>,

2595

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2596

        _: core::marker::PhantomData<(&'input ())>,

2597

    ) -> (usize, usize)

2598

2599

        // RBranch+ = RBranch+, RBranch => ActionFn(71);

2600

        assert!(__symbols.len() >= 2);

2601

        let __sym1 = __pop_Variant2(__symbols);

2602

        let __sym0 = __pop_Variant5(__symbols);

2603

        let __start = __sym0.0;

2604

        let __end = __sym1.2;

2605

        let __nt = super::__action71::<>(input, __sym0, __sym1);

2606

        __symbols.push((__start, __Symbol::Variant5(__nt), __end));

2607

        (2, 13)

2608

2609

    pub(crate) fn __reduce67<

2610

        'input,

2611

>(

2612

        input: &'input str,

2613

        __lookahead_start: Option<&usize>,

2614

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2615

        _: core::marker::PhantomData<(&'input ())>,

2616

    ) -> (usize, usize)

2617

2618

        // Range = LBRACKET, CARET, RBRACKET, RBRACKET => ActionFn(74);

2619

        assert!(__symbols.len() >= 4);

2620

        let __sym3 = __pop_Variant0(__symbols);

2621

        let __sym2 = __pop_Variant0(__symbols);

2622

        let __sym1 = __pop_Variant0(__symbols);

2623

        let __sym0 = __pop_Variant0(__symbols);

2624

        let __start = __sym0.0;

2625

        let __end = __sym3.2;

2626

        let __nt = super::__action74::<>(input, __sym0, __sym1, __sym2, __sym3);

2627

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2628

        (4, 14)

2629

2630

    pub(crate) fn __reduce68<

2631

        'input,

2632

>(

2633

        input: &'input str,

2634

        __lookahead_start: Option<&usize>,

2635

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2636

        _: core::marker::PhantomData<(&'input ())>,

2637

    ) -> (usize, usize)

2638

2639

        // Range = LBRACKET, CARET, RBRACKET, NotRBracket+, RBRACKET => ActionFn(75);

2640

        assert!(__symbols.len() >= 5);

2641

        let __sym4 = __pop_Variant0(__symbols);

2642

        let __sym3 = __pop_Variant4(__symbols);

2643

        let __sym2 = __pop_Variant0(__symbols);

2644

        let __sym1 = __pop_Variant0(__symbols);

2645

        let __sym0 = __pop_Variant0(__symbols);

2646

        let __start = __sym0.0;

2647

        let __end = __sym4.2;

2648

        let __nt = super::__action75::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4);

2649

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2650

        (5, 14)

2651

2652

    pub(crate) fn __reduce69<

2653

        'input,

2654

>(

2655

        input: &'input str,

2656

        __lookahead_start: Option<&usize>,

2657

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2658

        _: core::marker::PhantomData<(&'input ())>,

2659

    ) -> (usize, usize)

2660

2661

        // Range = LBRACKET, RBRACKET, RBRACKET => ActionFn(76);

2662

        assert!(__symbols.len() >= 3);

2663

        let __sym2 = __pop_Variant0(__symbols);

2664

        let __sym1 = __pop_Variant0(__symbols);

2665

        let __sym0 = __pop_Variant0(__symbols);

2666

        let __start = __sym0.0;

2667

        let __end = __sym2.2;

2668

        let __nt = super::__action76::<>(input, __sym0, __sym1, __sym2);

2669

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2670

        (3, 14)

2671

2672

    pub(crate) fn __reduce70<

2673

        'input,

2674

>(

2675

        input: &'input str,

2676

        __lookahead_start: Option<&usize>,

2677

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2678

        _: core::marker::PhantomData<(&'input ())>,

2679

    ) -> (usize, usize)

2680

2681

        // Range = LBRACKET, RBRACKET, NotRBracket+, RBRACKET => ActionFn(77);

2682

        assert!(__symbols.len() >= 4);

2683

        let __sym3 = __pop_Variant0(__symbols);

2684

        let __sym2 = __pop_Variant4(__symbols);

2685

        let __sym1 = __pop_Variant0(__symbols);

2686

        let __sym0 = __pop_Variant0(__symbols);

2687

        let __start = __sym0.0;

2688

        let __end = __sym3.2;

2689

        let __nt = super::__action77::<>(input, __sym0, __sym1, __sym2, __sym3);

2690

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2691

        (4, 14)

2692

2693

    pub(crate) fn __reduce71<

2694

        'input,

2695

>(

2696

        input: &'input str,

2697

        __lookahead_start: Option<&usize>,

2698

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2699

        _: core::marker::PhantomData<(&'input ())>,

2700

    ) -> (usize, usize)

2701

2702

        // Range = LBRACKET, CARET, NotRBracket+, RBRACKET => ActionFn(19);

2703

        assert!(__symbols.len() >= 4);

2704

        let __sym3 = __pop_Variant0(__symbols);

2705

        let __sym2 = __pop_Variant4(__symbols);

2706

        let __sym1 = __pop_Variant0(__symbols);

2707

        let __sym0 = __pop_Variant0(__symbols);

2708

        let __start = __sym0.0;

2709

        let __end = __sym3.2;

2710

        let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2, __sym3);

2711

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2712

        (4, 14)

2713

2714

    pub(crate) fn __reduce72<

2715

        'input,

2716

>(

2717

        input: &'input str,

2718

        __lookahead_start: Option<&usize>,

2719

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2720

        _: core::marker::PhantomData<(&'input ())>,

2721

    ) -> (usize, usize)

2722

2723

        // Range = LBRACKET, NotCaretNotRBracket, RBRACKET => ActionFn(78);

2724

        assert!(__symbols.len() >= 3);

2725

        let __sym2 = __pop_Variant0(__symbols);

2726

        let __sym1 = __pop_Variant1(__symbols);

2727

        let __sym0 = __pop_Variant0(__symbols);

2728

        let __start = __sym0.0;

2729

        let __end = __sym2.2;

2730

        let __nt = super::__action78::<>(input, __sym0, __sym1, __sym2);

2731

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2732

        (3, 14)

2733

2734

    pub(crate) fn __reduce73<

2735

        'input,

2736

>(

2737

        input: &'input str,

2738

        __lookahead_start: Option<&usize>,

2739

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2740

        _: core::marker::PhantomData<(&'input ())>,

2741

    ) -> (usize, usize)

2742

2743

        // Range = LBRACKET, NotCaretNotRBracket, NotRBracket+, RBRACKET => ActionFn(79);

2744

        assert!(__symbols.len() >= 4);

2745

        let __sym3 = __pop_Variant0(__symbols);

2746

        let __sym2 = __pop_Variant4(__symbols);

2747

        let __sym1 = __pop_Variant1(__symbols);

2748

        let __sym0 = __pop_Variant0(__symbols);

2749

        let __start = __sym0.0;

2750

        let __end = __sym3.2;

2751

        let __nt = super::__action79::<>(input, __sym0, __sym1, __sym2, __sym3);

2752

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2753

        (4, 14)

2754

2755

    pub(crate) fn __reduce74<

2756

        'input,

2757

>(

2758

        input: &'input str,

2759

        __lookahead_start: Option<&usize>,

2760

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2761

        _: core::marker::PhantomData<(&'input ())>,

2762

    ) -> (usize, usize)

2763

2764

        // Regex = LBranch => ActionFn(80);

2765

        let __sym0 = __pop_Variant2(__symbols);

2766

        let __start = __sym0.0;

2767

        let __end = __sym0.2;

2768

        let __nt = super::__action80::<>(input, __sym0);

2769

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2770

        (1, 15)

2771

2772

    pub(crate) fn __reduce75<

2773

        'input,

2774

>(

2775

        input: &'input str,

2776

        __lookahead_start: Option<&usize>,

2777

        __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)>,

2778

        _: core::marker::PhantomData<(&'input ())>,

2779

    ) -> (usize, usize)

2780

2781

        // Regex = LBranch, RBranch+ => ActionFn(81);

2782

        assert!(__symbols.len() >= 2);

2783

        let __sym1 = __pop_Variant5(__symbols);

2784

        let __sym0 = __pop_Variant2(__symbols);

2785

        let __start = __sym0.0;

2786

        let __end = __sym1.2;

2787

        let __nt = super::__action81::<>(input, __sym0, __sym1);

2788

        __symbols.push((__start, __Symbol::Variant2(__nt), __end));

2789

        (2, 15)

2790

2791

2792

pub(crate) use self::__parse__Regex::RegexParser;

2793

2794

#[allow(unused_variables)]

2795

#[allow(clippy::too_many_arguments)]

2796

fn __action0<

2797

    'input,

2798

>(

2799

    input: &'input str,

2800

    (_, __0, _): (usize, Hir, usize),

2801

) -> Hir

2802

2803

__0

2804

2805

2806

#[allow(unused_variables)]

2807

#[allow(clippy::too_many_arguments)]

2808

fn __action1<

2809

    'input,

2810

>(

2811

    input: &'input str,

2812

    (_, l, _): (usize, Hir, usize),

2813

    (_, r, _): (usize, alloc::vec::Vec<Hir>, usize),

2814

) -> Hir

2815

2816

2817

        let mut r = r;

2818

        r.insert(0, l);

2819

2820

        // If any of the branches are empty, then that branch matches

2821

        // everything, and we can just short circuit the whole

2822

        // alternation.

2823

//

2824

        // This is actually required for version 1.3.7 of the regex

2825

        // crate, which is the version that is in Debian Bullseye.

2826

        // See issue #694 for details.

2827

        if r.iter().any(|b| *b.kind() == hir::HirKind::Empty) {

2828

            hir::Hir::empty()

2829

        } else {

2830

            Hir::alternation(r)

2831

2832

2833

2834

2835

#[allow(unused_variables)]

2836

#[allow(clippy::too_many_arguments)]

2837

fn __action2<

2838

    'input,

2839

>(

2840

    input: &'input str,

2841

    (_, __0, _): (usize, Hir, usize),

2842

) -> Hir

2843

2844

__0

2845

2846

2847

#[allow(unused_variables)]

2848

#[allow(clippy::too_many_arguments)]

2849

fn __action3<

2850

    'input,

2851

>(

2852

    input: &'input str,

2853

    (_, _, _): (usize, lexer::Token, usize),

2854

    (_, __0, _): (usize, Hir, usize),

2855

) -> Hir

2856

2857

__0

2858

2859

2860

#[allow(unused_variables)]

2861

#[allow(clippy::too_many_arguments)]

2862

fn __action4<

2863

    'input,

2864

>(

2865

    input: &'input str,

2866

    __lookbehind: &usize,

2867

    __lookahead: &usize,

2868

) -> Hir

2869

2870

2871

        hir::Hir::empty()

2872

2873

2874

2875

#[allow(unused_variables)]

2876

#[allow(clippy::too_many_arguments)]

2877

fn __action5<

2878

    'input,

2879

>(

2880

    input: &'input str,

2881

    (_, p, _): (usize, alloc::vec::Vec<Hir>, usize),

2882

) -> Hir

2883

2884

2885

        if p.iter().all(|p| *p.kind() == hir::HirKind::Empty) {

2886

            // All pieces are empty.  Just return empty.

2887

            hir::Hir::empty()

2888

        } else {

2889

            hir::Hir::concat(p)

2890

2891

2892

2893

2894

#[allow(unused_variables)]

2895

#[allow(clippy::too_many_arguments)]

2896

fn __action6<

2897

    'input,

2898

>(

2899

    input: &'input str,

2900

    (_, a, _): (usize, Hir, usize),

2901

) -> Hir

2902

2903

2904

2905

2906

#[allow(unused_variables)]

2907

#[allow(clippy::too_many_arguments)]

2908

fn __action7<

2909

    'input,

2910

>(

2911

    input: &'input str,

2912

    (_, a, _): (usize, Hir, usize),

2913

    (_, _, _): (usize, lexer::Token, usize),

2914

) -> Hir

2915

2916

2917

        if *a.kind() == hir::HirKind::Empty {

2918

            // Piece is empty.  This is equivalent to empty so just

2919

            // return it.

2920

2921

        } else {

2922

            hir::Hir::repetition(hir::Repetition {

2923

                min: 0,

2924

                max: None,

2925

                greedy: true,

2926

                sub: Box::new(a)

2927

})

2928

2929

2930

2931

2932

#[allow(unused_variables)]

2933

#[allow(clippy::too_many_arguments)]

2934

fn __action8<

2935

    'input,

2936

>(

2937

    input: &'input str,

2938

    (_, a, _): (usize, Hir, usize),

2939

    (_, _, _): (usize, lexer::Token, usize),

2940

) -> Hir

2941

2942

2943

        if *a.kind() == hir::HirKind::Empty {

2944

            // Piece is empty.  This is equivalent to empty so just

2945

            // return it.

2946

2947

        } else {

2948

            hir::Hir::repetition(hir::Repetition {

2949

                min: 1,

2950

                max: None,

2951

                greedy: true,

2952

                sub: Box::new(a)

2953

})

2954

2955

2956

2957

2958

#[allow(unused_variables)]

2959

#[allow(clippy::too_many_arguments)]

2960

fn __action9<

2961

    'input,

2962

>(

2963

    input: &'input str,

2964

    (_, a, _): (usize, Hir, usize),

2965

    (_, _, _): (usize, lexer::Token, usize),

2966

) -> Hir

2967

2968

2969

        if *a.kind() == hir::HirKind::Empty {

2970

            // Piece is empty.  This is equivalent to empty so just

2971

            // return it.

2972

2973

        } else {

2974

            hir::Hir::repetition(hir::Repetition {

2975

                min: 0,

2976

                max: Some(1),

2977

                greedy: true,

2978

                sub: Box::new(a)

2979

})

2980

2981

2982

2983

2984

#[allow(unused_variables)]

2985

#[allow(clippy::too_many_arguments)]

2986

fn __action10<

2987

    'input,

2988

>(

2989

    input: &'input str,

2990

    (_, _, _): (usize, lexer::Token, usize),

2991

    (_, r, _): (usize, Hir, usize),

2992

    (_, _, _): (usize, lexer::Token, usize),

2993

) -> Hir

2994

2995

2996

2997

2998

2999

3000

#[allow(unused_variables)]

3001

#[allow(clippy::too_many_arguments)]

3002

fn __action11<

3003

    'input,

3004

>(

3005

    input: &'input str,

3006

    (_, __0, _): (usize, Hir, usize),

3007

) -> Hir

3008

3009

__0

3010

3011

3012

#[allow(unused_variables)]

3013

#[allow(clippy::too_many_arguments)]

3014

fn __action12<

3015

    'input,

3016

>(

3017

    input: &'input str,

3018

    (_, __0, _): (usize, lexer::Token, usize),

3019

) -> Hir

3020

3021

3022

        hir::Hir::dot(hir::Dot::AnyChar)

3023

3024

3025

3026

#[allow(unused_variables)]

3027

#[allow(clippy::too_many_arguments)]

3028

fn __action13<

3029

    'input,

3030

>(

3031

    input: &'input str,

3032

    (_, __0, _): (usize, lexer::Token, usize),

3033

) -> Hir

3034

3035

3036

        hir::Hir::look(hir::Look::Start)

3037

3038

3039

3040

#[allow(unused_variables)]

3041

#[allow(clippy::too_many_arguments)]

3042

fn __action14<

3043

    'input,

3044

>(

3045

    input: &'input str,

3046

    (_, __0, _): (usize, lexer::Token, usize),

3047

) -> Hir

3048

3049

3050

        hir::Hir::look(hir::Look::End)

3051

3052

3053

3054

#[allow(unused_variables)]

3055

#[allow(clippy::too_many_arguments)]

3056

fn __action15<

3057

    'input,

3058

>(

3059

    input: &'input str,

3060

    (_, _, _): (usize, lexer::Token, usize),

3061

    (_, t, _): (usize, Token, usize),

3062

) -> Hir

3063

3064

3065

        // "A buffer of length four is large enough to encode any

3066

        // char."

3067

//

3068

        // https://doc.rust-lang.org/std/primitive.char.html#method.encode_utf8

3069

        let mut buffer = [0; 4];

3070

        // Convert the Unicode character t to a string.

3071

        let s = t.to_char().encode_utf8(&mut buffer);

3072

        hir::Hir::literal(s.as_bytes())

3073

3074

3075

3076

#[allow(unused_variables)]

3077

#[allow(clippy::too_many_arguments)]

3078

fn __action16<

3079

    'input,

3080

>(

3081

    input: &'input str,

3082

    (_, __0, _): (usize, lexer::Token, usize),

3083

) -> Hir

3084

3085

3086

        hir::Hir::literal("-".as_bytes())

3087

3088

3089

3090

#[allow(unused_variables)]

3091

#[allow(clippy::too_many_arguments)]

3092

fn __action17<

3093

    'input,

3094

>(

3095

    input: &'input str,

3096

    (_, t, _): (usize, lexer::Token, usize),

3097

) -> Hir

3098

3099

3100

        // "A buffer of length four is large enough to encode any

3101

        // char."

3102

//

3103

        // https://doc.rust-lang.org/std/primitive.char.html#method.encode_utf8

3104

        let mut buffer = [0; 4];

3105

        let s = t.to_char().encode_utf8(&mut buffer);

3106

        hir::Hir::literal(s.as_bytes())

3107

3108

3109

3110

#[allow(unused_variables)]

3111

#[allow(clippy::too_many_arguments)]

3112

fn __action18<

3113

    'input,

3114

>(

3115

    input: &'input str,

3116

    (_, _, _): (usize, lexer::Token, usize),

3117

    (_, c, _): (usize, core::option::Option<lexer::Token>, usize),

3118

    (_, class1, _): (usize, lexer::Token, usize),

3119

    (_, class2, _): (usize, alloc::vec::Vec<Token>, usize),

3120

    (_, _, _): (usize, lexer::Token, usize),

3121

) -> Hir

3122

3123

3124

        generate_class(c.is_some(),

3125

                       std::iter::once(class1.to_char())

3126

                       .chain(class2.into_iter().map(|t| t.to_char())))

3127

3128

3129

3130

#[allow(unused_variables)]

3131

#[allow(clippy::too_many_arguments)]

3132

fn __action19<

3133

    'input,

3134

>(

3135

    input: &'input str,

3136

    (_, _, _): (usize, lexer::Token, usize),

3137

    (_, _, _): (usize, lexer::Token, usize),

3138

    (_, class, _): (usize, alloc::vec::Vec<Token>, usize),

3139

    (_, _, _): (usize, lexer::Token, usize),

3140

) -> Hir

3141

3142

3143

        generate_class(true,

3144

                       class.into_iter().map(|t| t.to_char()))

3145

3146

3147

3148

#[allow(unused_variables)]

3149

#[allow(clippy::too_many_arguments)]

3150

fn __action20<

3151

    'input,

3152

>(

3153

    input: &'input str,

3154

    (_, _, _): (usize, lexer::Token, usize),

3155

    (_, class1, _): (usize, Token, usize),

3156

    (_, class2, _): (usize, alloc::vec::Vec<Token>, usize),

3157

    (_, _, _): (usize, lexer::Token, usize),

3158

) -> Hir

3159

3160

3161

        generate_class(false,

3162

                       std::iter::once(class1.to_char())

3163

                       .chain(class2.into_iter().map(|t| t.to_char())))

3164

3165

3166

3167

#[allow(unused_variables)]

3168

#[allow(clippy::too_many_arguments)]

3169

fn __action21<

3170

    'input,

3171

>(

3172

    input: &'input str,

3173

    (_, __0, _): (usize, lexer::Token, usize),

3174

) -> Token

3175

3176

    Token::OTHER('|')

3177

3178

3179

#[allow(unused_variables)]

3180

#[allow(clippy::too_many_arguments)]

3181

fn __action22<

3182

    'input,

3183

>(

3184

    input: &'input str,

3185

    (_, __0, _): (usize, lexer::Token, usize),

3186

) -> Token

3187

3188

    Token::OTHER('*')

3189

3190

3191

#[allow(unused_variables)]

3192

#[allow(clippy::too_many_arguments)]

3193

fn __action23<

3194

    'input,

3195

>(

3196

    input: &'input str,

3197

    (_, __0, _): (usize, lexer::Token, usize),

3198

) -> Token

3199

3200

    Token::OTHER('+')

3201

3202

3203

#[allow(unused_variables)]

3204

#[allow(clippy::too_many_arguments)]

3205

fn __action24<

3206

    'input,

3207

>(

3208

    input: &'input str,

3209

    (_, __0, _): (usize, lexer::Token, usize),

3210

) -> Token

3211

3212

    Token::OTHER('?')

3213

3214

3215

#[allow(unused_variables)]

3216

#[allow(clippy::too_many_arguments)]

3217

fn __action25<

3218

    'input,

3219

>(

3220

    input: &'input str,

3221

    (_, __0, _): (usize, lexer::Token, usize),

3222

) -> Token

3223

3224

    Token::OTHER('(')

3225

3226

3227

#[allow(unused_variables)]

3228

#[allow(clippy::too_many_arguments)]

3229

fn __action26<

3230

    'input,

3231

>(

3232

    input: &'input str,

3233

    (_, __0, _): (usize, lexer::Token, usize),

3234

) -> Token

3235

3236

    Token::OTHER(')')

3237

3238

3239

#[allow(unused_variables)]

3240

#[allow(clippy::too_many_arguments)]

3241

fn __action27<

3242

    'input,

3243

>(

3244

    input: &'input str,

3245

    (_, __0, _): (usize, lexer::Token, usize),

3246

) -> Token

3247

3248

    Token::OTHER('.')

3249

3250

3251

#[allow(unused_variables)]

3252

#[allow(clippy::too_many_arguments)]

3253

fn __action28<

3254

    'input,

3255

>(

3256

    input: &'input str,

3257

    (_, __0, _): (usize, lexer::Token, usize),

3258

) -> Token

3259

3260

    Token::OTHER('^')

3261

3262

3263

#[allow(unused_variables)]

3264

#[allow(clippy::too_many_arguments)]

3265

fn __action29<

3266

    'input,

3267

>(

3268

    input: &'input str,

3269

    (_, __0, _): (usize, lexer::Token, usize),

3270

) -> Token

3271

3272

    Token::OTHER('$')

3273

3274

3275

#[allow(unused_variables)]

3276

#[allow(clippy::too_many_arguments)]

3277

fn __action30<

3278

    'input,

3279

>(

3280

    input: &'input str,

3281

    (_, __0, _): (usize, lexer::Token, usize),

3282

) -> Token

3283

3284

    Token::OTHER('\\')

3285

3286

3287

#[allow(unused_variables)]

3288

#[allow(clippy::too_many_arguments)]

3289

fn __action31<

3290

    'input,

3291

>(

3292

    input: &'input str,

3293

    (_, __0, _): (usize, lexer::Token, usize),

3294

) -> Token

3295

3296

    Token::OTHER('[')

3297

3298

3299

#[allow(unused_variables)]

3300

#[allow(clippy::too_many_arguments)]

3301

fn __action32<

3302

    'input,

3303

>(

3304

    input: &'input str,

3305

    (_, __0, _): (usize, lexer::Token, usize),

3306

) -> Token

3307

3308

    Token::OTHER('-')

3309

3310

3311

#[allow(unused_variables)]

3312

#[allow(clippy::too_many_arguments)]

3313

fn __action33<

3314

    'input,

3315

>(

3316

    input: &'input str,

3317

    (_, __0, _): (usize, lexer::Token, usize),

3318

) -> Token

3319

3320

__0

3321

3322

3323

#[allow(unused_variables)]

3324

#[allow(clippy::too_many_arguments)]

3325

fn __action34<

3326

    'input,

3327

>(

3328

    input: &'input str,

3329

    (_, __0, _): (usize, lexer::Token, usize),

3330

) -> Token

3331

3332

    Token::OTHER('|')

3333

3334

3335

#[allow(unused_variables)]

3336

#[allow(clippy::too_many_arguments)]

3337

fn __action35<

3338

    'input,

3339

>(

3340

    input: &'input str,

3341

    (_, __0, _): (usize, lexer::Token, usize),

3342

) -> Token

3343

3344

    Token::OTHER('*')

3345

3346

3347

#[allow(unused_variables)]

3348

#[allow(clippy::too_many_arguments)]

3349

fn __action36<

3350

    'input,

3351

>(

3352

    input: &'input str,

3353

    (_, __0, _): (usize, lexer::Token, usize),

3354

) -> Token

3355

3356

    Token::OTHER('+')

3357

3358

3359

#[allow(unused_variables)]

3360

#[allow(clippy::too_many_arguments)]

3361

fn __action37<

3362

    'input,

3363

>(

3364

    input: &'input str,

3365

    (_, __0, _): (usize, lexer::Token, usize),

3366

) -> Token

3367

3368

    Token::OTHER('?')

3369

3370

3371

#[allow(unused_variables)]

3372

#[allow(clippy::too_many_arguments)]

3373

fn __action38<

3374

    'input,

3375

>(

3376

    input: &'input str,

3377

    (_, __0, _): (usize, lexer::Token, usize),

3378

) -> Token

3379

3380

    Token::OTHER('(')

3381

3382

3383

#[allow(unused_variables)]

3384

#[allow(clippy::too_many_arguments)]

3385

fn __action39<

3386

    'input,

3387

>(

3388

    input: &'input str,

3389

    (_, __0, _): (usize, lexer::Token, usize),

3390

) -> Token

3391

3392

    Token::OTHER(')')

3393

3394

3395

#[allow(unused_variables)]

3396

#[allow(clippy::too_many_arguments)]

3397

fn __action40<

3398

    'input,

3399

>(

3400

    input: &'input str,

3401

    (_, __0, _): (usize, lexer::Token, usize),

3402

) -> Token

3403

3404

    Token::OTHER('.')

3405

3406

3407

#[allow(unused_variables)]

3408

#[allow(clippy::too_many_arguments)]

3409

fn __action41<

3410

    'input,

3411

>(

3412

    input: &'input str,

3413

    (_, __0, _): (usize, lexer::Token, usize),

3414

) -> Token

3415

3416

    Token::OTHER('$')

3417

3418

3419

#[allow(unused_variables)]

3420

#[allow(clippy::too_many_arguments)]

3421

fn __action42<

3422

    'input,

3423

>(

3424

    input: &'input str,

3425

    (_, __0, _): (usize, lexer::Token, usize),

3426

) -> Token

3427

3428

    Token::OTHER('\\')

3429

3430

3431

#[allow(unused_variables)]

3432

#[allow(clippy::too_many_arguments)]

3433

fn __action43<

3434

    'input,

3435

>(

3436

    input: &'input str,

3437

    (_, __0, _): (usize, lexer::Token, usize),

3438

) -> Token

3439

3440

    Token::OTHER('[')

3441

3442

3443

#[allow(unused_variables)]

3444

#[allow(clippy::too_many_arguments)]

3445

fn __action44<

3446

    'input,

3447

>(

3448

    input: &'input str,

3449

    (_, __0, _): (usize, lexer::Token, usize),

3450

) -> Token

3451

3452

    Token::OTHER('-')

3453

3454

3455

#[allow(unused_variables)]

3456

#[allow(clippy::too_many_arguments)]

3457

fn __action45<

3458

    'input,

3459

>(

3460

    input: &'input str,

3461

    (_, __0, _): (usize, lexer::Token, usize),

3462

) -> Token

3463

3464

__0

3465

3466

3467

#[allow(unused_variables)]

3468

#[allow(clippy::too_many_arguments)]

3469

fn __action46<

3470

    'input,

3471

>(

3472

    input: &'input str,

3473

    (_, __0, _): (usize, lexer::Token, usize),

3474

) -> Token

3475

3476

    Token::OTHER('|')

3477

3478

3479

#[allow(unused_variables)]

3480

#[allow(clippy::too_many_arguments)]

3481

fn __action47<

3482

    'input,

3483

>(

3484

    input: &'input str,

3485

    (_, __0, _): (usize, lexer::Token, usize),

3486

) -> Token

3487

3488

    Token::OTHER('*')

3489

3490

3491

#[allow(unused_variables)]

3492

#[allow(clippy::too_many_arguments)]

3493

fn __action48<

3494

    'input,

3495

>(

3496

    input: &'input str,

3497

    (_, __0, _): (usize, lexer::Token, usize),

3498

) -> Token

3499

3500

    Token::OTHER('+')

3501

3502

3503

#[allow(unused_variables)]

3504

#[allow(clippy::too_many_arguments)]

3505

fn __action49<

3506

    'input,

3507

>(

3508

    input: &'input str,

3509

    (_, __0, _): (usize, lexer::Token, usize),

3510

) -> Token

3511

3512

    Token::OTHER('?')

3513

3514

3515

#[allow(unused_variables)]

3516

#[allow(clippy::too_many_arguments)]

3517

fn __action50<

3518

    'input,

3519

>(

3520

    input: &'input str,

3521

    (_, __0, _): (usize, lexer::Token, usize),

3522

) -> Token

3523

3524

    Token::OTHER('(')

3525

3526

3527

#[allow(unused_variables)]

3528

#[allow(clippy::too_many_arguments)]

3529

fn __action51<

3530

    'input,

3531

>(

3532

    input: &'input str,

3533

    (_, __0, _): (usize, lexer::Token, usize),

3534

) -> Token

3535

3536

    Token::OTHER(')')

3537

3538

3539

#[allow(unused_variables)]

3540

#[allow(clippy::too_many_arguments)]

3541

fn __action52<

3542

    'input,

3543

>(

3544

    input: &'input str,

3545

    (_, __0, _): (usize, lexer::Token, usize),

3546

) -> Token

3547

3548

    Token::OTHER('.')

3549

3550

3551

#[allow(unused_variables)]

3552

#[allow(clippy::too_many_arguments)]

3553

fn __action53<

3554

    'input,

3555

>(

3556

    input: &'input str,

3557

    (_, __0, _): (usize, lexer::Token, usize),

3558

) -> Token

3559

3560

    Token::OTHER('^')

3561

3562

3563

#[allow(unused_variables)]

3564

#[allow(clippy::too_many_arguments)]

3565

fn __action54<

3566

    'input,

3567

>(

3568

    input: &'input str,

3569

    (_, __0, _): (usize, lexer::Token, usize),

3570

) -> Token

3571

3572

    Token::OTHER('$')

3573

3574

3575

#[allow(unused_variables)]

3576

#[allow(clippy::too_many_arguments)]

3577

fn __action55<

3578

    'input,

3579

>(

3580

    input: &'input str,

3581

    (_, __0, _): (usize, lexer::Token, usize),

3582

) -> Token

3583

3584

    Token::OTHER('\\')

3585

3586

3587

#[allow(unused_variables)]

3588

#[allow(clippy::too_many_arguments)]

3589

fn __action56<

3590

    'input,

3591

>(

3592

    input: &'input str,

3593

    (_, __0, _): (usize, lexer::Token, usize),

3594

) -> Token

3595

3596

    Token::OTHER('[')

3597

3598

3599

#[allow(unused_variables)]

3600

#[allow(clippy::too_many_arguments)]

3601

fn __action57<

3602

    'input,

3603

>(

3604

    input: &'input str,

3605

    (_, __0, _): (usize, lexer::Token, usize),

3606

) -> Token

3607

3608

    Token::OTHER(']')

3609

3610

3611

#[allow(unused_variables)]

3612

#[allow(clippy::too_many_arguments)]

3613

fn __action58<

3614

    'input,

3615

>(

3616

    input: &'input str,

3617

    (_, __0, _): (usize, lexer::Token, usize),

3618

) -> Token

3619

3620

    Token::OTHER('-')

3621

3622

3623

#[allow(unused_variables)]

3624

#[allow(clippy::too_many_arguments)]

3625

fn __action59<

3626

    'input,

3627

>(

3628

    input: &'input str,

3629

    (_, __0, _): (usize, lexer::Token, usize),

3630

) -> Token

3631

3632

__0

3633

3634

3635

#[allow(unused_variables)]

3636

#[allow(clippy::too_many_arguments)]

3637

fn __action60<

3638

    'input,

3639

>(

3640

    input: &'input str,

3641

    (_, __0, _): (usize, Token, usize),

3642

) -> alloc::vec::Vec<Token>

3643

3644

    alloc::vec![__0]

3645

3646

3647

#[allow(unused_variables)]

3648

#[allow(clippy::too_many_arguments)]

3649

fn __action61<

3650

    'input,

3651

>(

3652

    input: &'input str,

3653

    (_, v, _): (usize, alloc::vec::Vec<Token>, usize),

3654

    (_, e, _): (usize, Token, usize),

3655

) -> alloc::vec::Vec<Token>

3656

3657

    { let mut v = v; v.push(e); v }

3658

3659

3660

#[allow(unused_variables)]

3661

#[allow(clippy::too_many_arguments)]

3662

fn __action62<

3663

    'input,

3664

>(

3665

    input: &'input str,

3666

    __lookbehind: &usize,

3667

    __lookahead: &usize,

3668

) -> alloc::vec::Vec<Token>

3669

3670

    alloc::vec![]

3671

3672

3673

#[allow(unused_variables)]

3674

#[allow(clippy::too_many_arguments)]

3675

fn __action63<

3676

    'input,

3677

>(

3678

    input: &'input str,

3679

    (_, v, _): (usize, alloc::vec::Vec<Token>, usize),

3680

) -> alloc::vec::Vec<Token>

3681

3682

3683

3684

3685

#[allow(unused_variables)]

3686

#[allow(clippy::too_many_arguments)]

3687

fn __action64<

3688

    'input,

3689

>(

3690

    input: &'input str,

3691

    (_, __0, _): (usize, lexer::Token, usize),

3692

) -> core::option::Option<lexer::Token>

3693

3694

    Some(__0)

3695

3696

3697

#[allow(unused_variables)]

3698

#[allow(clippy::too_many_arguments)]

3699

fn __action65<

3700

    'input,

3701

>(

3702

    input: &'input str,

3703

    __lookbehind: &usize,

3704

    __lookahead: &usize,

3705

) -> core::option::Option<lexer::Token>

3706

3707

    None

3708

3709

3710

#[allow(unused_variables)]

3711

#[allow(clippy::too_many_arguments)]

3712

fn __action66<

3713

    'input,

3714

>(

3715

    input: &'input str,

3716

    (_, __0, _): (usize, Hir, usize),

3717

) -> alloc::vec::Vec<Hir>

3718

3719

    alloc::vec![__0]

3720

3721

3722

#[allow(unused_variables)]

3723

#[allow(clippy::too_many_arguments)]

3724

fn __action67<

3725

    'input,

3726

>(

3727

    input: &'input str,

3728

    (_, v, _): (usize, alloc::vec::Vec<Hir>, usize),

3729

    (_, e, _): (usize, Hir, usize),

3730

) -> alloc::vec::Vec<Hir>

3731

3732

    { let mut v = v; v.push(e); v }

3733

3734

3735

#[allow(unused_variables)]

3736

#[allow(clippy::too_many_arguments)]

3737

fn __action68<

3738

    'input,

3739

>(

3740

    input: &'input str,

3741

    __lookbehind: &usize,

3742

    __lookahead: &usize,

3743

) -> alloc::vec::Vec<Hir>

3744

3745

    alloc::vec![]

3746

3747

3748

#[allow(unused_variables)]

3749

#[allow(clippy::too_many_arguments)]

3750

fn __action69<

3751

    'input,

3752

>(

3753

    input: &'input str,

3754

    (_, v, _): (usize, alloc::vec::Vec<Hir>, usize),

3755

) -> alloc::vec::Vec<Hir>

3756

3757

3758

3759

3760

#[allow(unused_variables)]

3761

#[allow(clippy::too_many_arguments)]

3762

fn __action70<

3763

    'input,

3764

>(

3765

    input: &'input str,

3766

    (_, __0, _): (usize, Hir, usize),

3767

) -> alloc::vec::Vec<Hir>

3768

3769

    alloc::vec![__0]

3770

3771

3772

#[allow(unused_variables)]

3773

#[allow(clippy::too_many_arguments)]

3774

fn __action71<

3775

    'input,

3776

>(

3777

    input: &'input str,

3778

    (_, v, _): (usize, alloc::vec::Vec<Hir>, usize),

3779

    (_, e, _): (usize, Hir, usize),

3780

) -> alloc::vec::Vec<Hir>

3781

3782

    { let mut v = v; v.push(e); v }

3783

3784

3785

#[allow(unused_variables)]

3786

#[allow(clippy::too_many_arguments)]

3787

fn __action72<

3788

    'input,

3789

>(

3790

    input: &'input str,

3791

    __0: (usize, lexer::Token, usize),

3792

    __1: (usize, lexer::Token, usize),

3793

    __2: (usize, lexer::Token, usize),

3794

    __3: (usize, alloc::vec::Vec<Token>, usize),

3795

    __4: (usize, lexer::Token, usize),

3796

) -> Hir

3797

3798

    let __start0 = __1.0;

3799

    let __end0 = __1.2;

3800

    let __temp0 = __action64(

3801

        input,

3802

        __1,

3803

);

3804

    let __temp0 = (__start0, __temp0, __end0);

3805

    __action18(

3806

        input,

3807

        __0,

3808

        __temp0,

3809

        __2,

3810

        __3,

3811

        __4,

3812

3813

3814

3815

#[allow(unused_variables)]

3816

#[allow(clippy::too_many_arguments)]

3817

fn __action73<

3818

    'input,

3819

>(

3820

    input: &'input str,

3821

    __0: (usize, lexer::Token, usize),

3822

    __1: (usize, lexer::Token, usize),

3823

    __2: (usize, alloc::vec::Vec<Token>, usize),

3824

    __3: (usize, lexer::Token, usize),

3825

) -> Hir

3826

3827

    let __start0 = __0.2;

3828

    let __end0 = __1.0;

3829

    let __temp0 = __action65(

3830

        input,

3831

        &__start0,

3832

        &__end0,

3833

);

3834

    let __temp0 = (__start0, __temp0, __end0);

3835

    __action18(

3836

        input,

3837

        __0,

3838

        __temp0,

3839

        __1,

3840

        __2,

3841

        __3,

3842

3843

3844

3845

#[allow(unused_variables)]

3846

#[allow(clippy::too_many_arguments)]

3847

fn __action74<

3848

    'input,

3849

>(

3850

    input: &'input str,

3851

    __0: (usize, lexer::Token, usize),

3852

    __1: (usize, lexer::Token, usize),

3853

    __2: (usize, lexer::Token, usize),

3854

    __3: (usize, lexer::Token, usize),

3855

) -> Hir

3856

3857

    let __start0 = __2.2;

3858

    let __end0 = __3.0;

3859

    let __temp0 = __action62(

3860

        input,

3861

        &__start0,

3862

        &__end0,

3863

);

3864

    let __temp0 = (__start0, __temp0, __end0);

3865

    __action72(

3866

        input,

3867

        __0,

3868

        __1,

3869

        __2,

3870

        __temp0,

3871

        __3,

3872

3873

3874

3875

#[allow(unused_variables)]

3876

#[allow(clippy::too_many_arguments)]

3877

fn __action75<

3878

    'input,

3879

>(

3880

    input: &'input str,

3881

    __0: (usize, lexer::Token, usize),

3882

    __1: (usize, lexer::Token, usize),

3883

    __2: (usize, lexer::Token, usize),

3884

    __3: (usize, alloc::vec::Vec<Token>, usize),

3885

    __4: (usize, lexer::Token, usize),

3886

) -> Hir

3887

3888

    let __start0 = __3.0;

3889

    let __end0 = __3.2;

3890

    let __temp0 = __action63(

3891

        input,

3892

        __3,

3893

);

3894

    let __temp0 = (__start0, __temp0, __end0);

3895

    __action72(

3896

        input,

3897

        __0,

3898

        __1,

3899

        __2,

3900

        __temp0,

3901

        __4,

3902

3903

3904

3905

#[allow(unused_variables)]

3906

#[allow(clippy::too_many_arguments)]

3907

fn __action76<

3908

    'input,

3909

>(

3910

    input: &'input str,

3911

    __0: (usize, lexer::Token, usize),

3912

    __1: (usize, lexer::Token, usize),

3913

    __2: (usize, lexer::Token, usize),

3914

) -> Hir

3915

3916

    let __start0 = __1.2;

3917

    let __end0 = __2.0;

3918

    let __temp0 = __action62(

3919

        input,

3920

        &__start0,

3921

        &__end0,

3922

);

3923

    let __temp0 = (__start0, __temp0, __end0);

3924

    __action73(

3925

        input,

3926

        __0,

3927

        __1,

3928

        __temp0,

3929

        __2,

3930

3931

3932

3933

#[allow(unused_variables)]

3934

#[allow(clippy::too_many_arguments)]

3935

fn __action77<

3936

    'input,

3937

>(

3938

    input: &'input str,

3939

    __0: (usize, lexer::Token, usize),

3940

    __1: (usize, lexer::Token, usize),

3941

    __2: (usize, alloc::vec::Vec<Token>, usize),

3942

    __3: (usize, lexer::Token, usize),

3943

) -> Hir

3944

3945

    let __start0 = __2.0;

3946

    let __end0 = __2.2;

3947

    let __temp0 = __action63(

3948

        input,

3949

        __2,

3950

);

3951

    let __temp0 = (__start0, __temp0, __end0);

3952

    __action73(

3953

        input,

3954

        __0,

3955

        __1,

3956

        __temp0,

3957

        __3,

3958

3959

3960

3961

#[allow(unused_variables)]

3962

#[allow(clippy::too_many_arguments)]

3963

fn __action78<

3964

    'input,

3965

>(

3966

    input: &'input str,

3967

    __0: (usize, lexer::Token, usize),

3968

    __1: (usize, Token, usize),

3969

    __2: (usize, lexer::Token, usize),

3970

) -> Hir

3971

3972

    let __start0 = __1.2;

3973

    let __end0 = __2.0;

3974

    let __temp0 = __action62(

3975

        input,

3976

        &__start0,

3977

        &__end0,

3978

);

3979

    let __temp0 = (__start0, __temp0, __end0);

3980

    __action20(

3981

        input,

3982

        __0,

3983

        __1,

3984

        __temp0,

3985

        __2,

3986

3987

3988

3989

#[allow(unused_variables)]

3990

#[allow(clippy::too_many_arguments)]

3991

fn __action79<

3992

    'input,

3993

>(

3994

    input: &'input str,

3995

    __0: (usize, lexer::Token, usize),

3996

    __1: (usize, Token, usize),

3997

    __2: (usize, alloc::vec::Vec<Token>, usize),

3998

    __3: (usize, lexer::Token, usize),

3999

) -> Hir

4000

4001

    let __start0 = __2.0;

4002

    let __end0 = __2.2;

4003

    let __temp0 = __action63(

4004

        input,

4005

        __2,

4006

);

4007

    let __temp0 = (__start0, __temp0, __end0);

4008

    __action20(

4009

        input,

4010

        __0,

4011

        __1,

4012

        __temp0,

4013

        __3,

4014

4015

4016

4017

#[allow(unused_variables)]

4018

#[allow(clippy::too_many_arguments)]

4019

fn __action80<

4020

    'input,

4021

>(

4022

    input: &'input str,

4023

    __0: (usize, Hir, usize),

4024

) -> Hir

4025

4026

    let __start0 = __0.2;

4027

    let __end0 = __0.2;

4028

    let __temp0 = __action68(

4029

        input,

4030

        &__start0,

4031

        &__end0,

4032

);

4033

    let __temp0 = (__start0, __temp0, __end0);

4034

    __action1(

4035

        input,

4036

        __0,

4037

        __temp0,

4038

4039

4040

4041

#[allow(unused_variables)]

4042

#[allow(clippy::too_many_arguments)]

4043

fn __action81<

4044

    'input,

4045

>(

4046

    input: &'input str,

4047

    __0: (usize, Hir, usize),

4048

    __1: (usize, alloc::vec::Vec<Hir>, usize),

4049

) -> Hir

4050

4051

    let __start0 = __1.0;

4052

    let __end0 = __1.2;

4053

    let __temp0 = __action69(

4054

        input,

4055

        __1,

4056

);

4057

    let __temp0 = (__start0, __temp0, __end0);

4058

    __action1(

4059

        input,

4060

        __0,

4061

        __temp0,

4062

4063

4064

#[allow(clippy::type_complexity)]

4065

4066

pub trait __ToTriple<'input, >

4067

4068

    fn to_triple(value: Self) -> Result<(usize,lexer::Token,usize), __lalrpop_util::ParseError<usize, lexer::Token, LexicalError>>;

4069

4070

4071

impl<'input, > __ToTriple<'input, > for (usize, lexer::Token, usize)

4072

4073

    fn to_triple(value: Self) -> Result<(usize,lexer::Token,usize), __lalrpop_util::ParseError<usize, lexer::Token, LexicalError>> {

4074

        Ok(value)

4075

4076

4077

impl<'input, > __ToTriple<'input, > for Result<(usize, lexer::Token, usize), LexicalError>

4078

4079

    fn to_triple(value: Self) -> Result<(usize,lexer::Token,usize), __lalrpop_util::ParseError<usize, lexer::Token, LexicalError>> {

4080

        match value {

4081

            Ok(v) => Ok(v),

4082

            Err(error) => Err(__lalrpop_util::ParseError::User { error }),

4083

4084

4085