scarf-parser 0.1.1

A helper crate of scarf for parsing a SystemVerilog source file
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// =======================================================================
// combinators.rs
// =======================================================================
// Custom combinators that note errors that may not be needed

use crate::*;
use winnow::Parser;
use winnow::combinator::trace;
use winnow::error::{ErrMode, ParserError};
use winnow::stream::{Accumulate, Stream};

pub fn repeat_note<'s, Output, ParseNext>(
    parser: ParseNext,
) -> RepeatNote<'s, ParseNext, Output>
where
    ParseNext: Parser<Tokens<'s>, Output, ErrMode<VerboseError<'s>>>,
{
    RepeatNote {
        parser,
        i: Default::default(),
        o: Default::default(),
    }
}

pub struct RepeatNote<'s, P, O>
where
    P: Parser<Tokens<'s>, O, ErrMode<VerboseError<'s>>>,
{
    parser: P,
    i: core::marker::PhantomData<Tokens<'s>>,
    o: core::marker::PhantomData<O>,
}

impl<'s, P, O> Parser<Tokens<'s>, Vec<O>, ErrMode<VerboseError<'s>>>
    for RepeatNote<'s, P, O>
where
    P: Parser<Tokens<'s>, O, ErrMode<VerboseError<'s>>>,
{
    #[inline(always)]
    fn parse_next(
        &mut self,
        i: &mut Tokens<'s>,
    ) -> Result<Vec<O>, ErrMode<VerboseError<'s>>> {
        trace("repeat_strict", move |i: &mut Tokens<'s>| {
            fold_repeat0_(
                &mut self.parser,
                &mut || Vec::initial(None),
                &mut |mut acc, o| {
                    acc.accumulate(o);
                    acc
                },
                i,
            )
        })
        .parse_next(i)
    }
}

fn fold_repeat0_<'s, O, P, N, F, R>(
    parser: &mut P,
    init: &mut N,
    fold: &mut F,
    input: &mut Tokens<'s>,
) -> Result<R, ErrMode<VerboseError<'s>>>
where
    P: Parser<Tokens<'s>, O, ErrMode<VerboseError<'s>>>,
    N: FnMut() -> R,
    F: FnMut(R, O) -> R,
{
    let mut res = init();

    loop {
        let start = input.checkpoint();
        let len = input.eof_offset();
        match parser.parse_next(input) {
            Ok(output) => {
                // infinite loop check: the parser must always consume
                if input.eof_offset() == len {
                    return Err(ParserError::assert(
                        input,
                        "`repeat_strict` parsers must always consume",
                    ));
                }

                res = fold(res, output);
            }
            Err(err) => match err {
                ErrMode::Backtrack(verbose_error) => {
                    input.reset(&start);
                    match &mut input.state {
                        None => input.state = Some(verbose_error),
                        Some(prev_error) => {
                            prev_error.or_in_place(verbose_error)
                        }
                    };
                    return Ok(res);
                }
                _ => return Err(err),
            },
        }
    }
}

pub fn opt_note<'s, Output, ParseNext>(
    mut parser: ParseNext,
) -> impl Parser<Tokens<'s>, Option<Output>, ErrMode<VerboseError<'s>>>
where
    ParseNext: Parser<Tokens<'s>, Output, ErrMode<VerboseError<'s>>>,
{
    trace("opt", move |input: &mut Tokens<'s>| {
        let start = input.checkpoint();
        match parser.parse_next(input) {
            Ok(o) => Ok(Some(o)),
            Err(err) => match err {
                ErrMode::Backtrack(verbose_error) => {
                    input.reset(&start);
                    match &mut input.state {
                        None => input.state = Some(verbose_error),
                        Some(prev_error) => {
                            prev_error.or_in_place(verbose_error)
                        }
                    };
                    return Ok(None);
                }
                _ => return Err(err),
            },
        }
    })
}