marser 0.1.0

Parser combinator toolkit with matcher-level backtracking and rich error reporting.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Matchers and parsers that only participate while real error handling is active.

use std::fmt::Display;

use crate::error::MatcherRunError;
use crate::matcher::internal::MatcherImpl;

#[derive(Debug, Clone)]
/// Wrapper that runs `inner` only during real error collection; otherwise it succeeds immediately.
pub struct IfError<Inner> {
    inner: Inner,
}

#[derive(Debug, Clone)]
/// Wrapper that runs `inner` only during real error collection; otherwise it fails immediately.
pub struct IfErrorElseFail<Inner> {
    inner: Inner,
}

impl<Inner> super::MatcherCombinator for IfError<Inner> where Inner: super::MatcherCombinator {}
impl<Inner> super::MatcherCombinator for IfErrorElseFail<Inner> where Inner: super::MatcherCombinator
{}

impl<Inner> crate::parser::ParserCombinator for IfErrorElseFail<Inner> where
    Inner: crate::parser::ParserCombinator
{
}

impl<Inner> IfError<Inner> {
    /// Wrap `inner`.
    pub fn new(inner: Inner) -> Self {
        Self { inner }
    }
}

impl<Inner> IfErrorElseFail<Inner> {
    /// Wrap `inner`.
    pub fn new(inner: Inner) -> Self {
        Self { inner }
    }
}

impl<'src, Inner, Inp: crate::input::Input<'src>, MRes>
    super::internal::MatcherImpl<'src, Inp, MRes> for IfError<Inner>
where
    Inner: MatcherImpl<'src, Inp, MRes>,
{
    const CAN_MATCH_DIRECTLY: bool = true;
    const HAS_PROPERTY: bool = false;
    const CAN_FAIL: bool = true;

    #[inline]
    fn match_with_runner<'a, Runner>(
        &'a self,
        runner: &mut Runner,
        error_handler: &mut impl crate::error::error_handler::ErrorHandler,
        input: &mut crate::input::InputStream<'src, Inp>,
    ) -> Result<bool, MatcherRunError>
    where
        Runner: super::MatchRunner<'a, 'src, Inp, MRes = MRes>,
        'src: 'a,
    {
        if !error_handler.is_real() {
            return Ok(true);
        }
        self.inner.match_with_runner(runner, error_handler, input)
    }

    #[inline]
    fn maybe_label(&self) -> Option<Box<dyn Display>> {
        self.inner.maybe_label()
    }
}

impl<'src, Inner, Inp: crate::input::Input<'src>, MRes>
    super::internal::MatcherImpl<'src, Inp, MRes> for IfErrorElseFail<Inner>
where
    Inner: MatcherImpl<'src, Inp, MRes>,
{
    const CAN_MATCH_DIRECTLY: bool = true;
    const HAS_PROPERTY: bool = false;
    const CAN_FAIL: bool = true;

    #[inline]
    fn match_with_runner<'a, Runner>(
        &'a self,
        runner: &mut Runner,
        error_handler: &mut impl crate::error::error_handler::ErrorHandler,
        input: &mut crate::input::InputStream<'src, Inp>,
    ) -> Result<bool, MatcherRunError>
    where
        Runner: super::MatchRunner<'a, 'src, Inp, MRes = MRes>,
        'src: 'a,
    {
        if !error_handler.is_real() {
            return Ok(false);
        }
        self.inner.match_with_runner(runner, error_handler, input)
    }

    #[inline]
    fn maybe_label(&self) -> Option<Box<dyn Display>> {
        self.inner.maybe_label()
    }
}

impl<'src, Inner, Inp: crate::input::Input<'src>> crate::parser::internal::ParserImpl<'src, Inp>
    for IfErrorElseFail<Inner>
where
    Inner: crate::parser::Parser<'src, Inp>,
{
    type Output = <Inner as crate::parser::internal::ParserImpl<'src, Inp>>::Output;
    const CAN_FAIL: bool = true;

    #[inline]
    fn parse(
        &self,
        context: &mut crate::context::ParserContext<'src>,
        error_handler: &mut impl crate::error::error_handler::ErrorHandler,
        input: &mut crate::input::InputStream<'src, Inp>,
    ) -> Result<Option<Self::Output>, crate::error::MatcherRunError> {
        if !error_handler.is_real() {
            return Ok(None);
        }
        self.inner.parse(context, error_handler, input)
    }

    #[inline]
    fn maybe_label(&self) -> Option<Box<dyn Display>> {
        self.inner.maybe_label()
    }
}

#[cfg_attr(feature = "parser-trace", track_caller)]
/// Run `inner` only when a real error handler is active; otherwise succeed without consuming input.
pub fn if_error<Inner>(inner: Inner) -> IfError<Inner>
where
    Inner: super::MatcherCombinator,
{
    IfError::new(inner)
}

#[cfg_attr(feature = "parser-trace", track_caller)]
/// Run `inner` only when a real error handler is active; otherwise fail without consuming input.
pub fn if_error_else_fail<Inner>(inner: Inner) -> IfErrorElseFail<Inner> {
    IfErrorElseFail::new(inner)
}