pigeon-core 0.2.0

Generate recursive-descent & precedence climbing parsers. (traits)
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

use core::marker::PhantomData;

use crate::*;

/// A simple wrapper to make ParseImpl easier to use. 
pub struct Parser<T>(PhantomData<T>);

impl<T> Parser<T> {
    /// Parse without extra value
    pub fn parse(input: &str) -> Result<T, ()> 
        where T: ParseImpl<0, false> + AstImpl<()>
    {
        // Parse input input a tag stack
        let mut trace = Vec::new();
        let mut stack = Vec::new();
        let end = 0;
        <T as ParseImpl<0, false>>::parse_impl(input, end, &mut trace, &mut stack)?;
        // Analyze the tag stack into this value
        Ok(T::ast(input, &stack, ()).1)
    }
    /// Parse with extra value provided
    pub fn parse_with<Extra>(input: &str, with: Extra) -> Result<T, ()> 
        where T: ParseImpl<0, false> + AstImpl<Extra>,
              Extra: Copy
    {
        // Parse input input a tag stack
        let mut trace = Vec::new();
        let mut stack = Vec::new();
        let end = 0;
        <T as ParseImpl<0, false>>::parse_impl(input, end, &mut trace, &mut stack)?;
        // Analyze the tag stack into this value, with extra value attached
        Ok(T::ast(input, &stack, with).1)
    }
    /// Only parse into a tag stack
    pub fn sequence(input: &str) -> Result<Vec<Tag>, ()> 
        where T: ParseImpl<0, false> + AstImpl<()>
    {
        let mut trace = Vec::new();
        let mut stack = Vec::new();
        let end = 0;
        <T as ParseImpl<0, false>>::parse_impl(input, end, &mut trace, &mut stack)?;
        Ok(stack)
    }
}