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

use {Result, Input};
use parsers::*;

#[macro_export]
macro_rules! any {
    ($input:expr, $case:expr, $($rest:expr),*) => (
        match parse!($input, $case) {
            $crate::Result::Ok(output) => {
                $crate::Result::Ok(output)
            }
            $crate::Result::Err(_) => {
                any!($input, $($rest),*)
            }
        }
    );

    ($input:expr, $case:expr) => (
        parse!($input, $case)
    )
}

#[macro_export]
macro_rules! maybe {
    ($input:expr, $value:expr) => ({
        match parse!($input, $value) {
            $crate::Result::Ok(val) => {
                $crate::Result::Ok(Some(val))
            }
            $crate::Result::Err(_) => {
                $crate::Result::Ok(None)
            }
        }
    })
}

#[macro_export]
macro_rules! collect {
    // Ideally we could just call `repeat_while!` here, but rust says that it
    // doesn't have enough type information.
    ($input:expr, $value:expr, $cond:expr) => ({
        let mut values = Vec::new();
        #[warn(unused_assignments)]
        loop {
            if let $crate::Result::Ok(_) = eof($input) {
                break;
            }

            match parse!($input, $value) {
                $crate::Result::Ok(value) => values.push(value),
                $crate::Result::Err(_) => break
            }

            if let $crate::Result::Err(_) = parse!($input, $cond) {
                break;
            }
        }

        $crate::Result::Ok(values)
    });

    ($input:expr, $value:expr) => ({
        let mut values = Vec::new();
        #[warn(unused_assignments)]
        loop {
            if let $crate::Result::Ok(_) = eof($input) {
                break;
            }

            match parse!($input, $value) {
                $crate::Result::Ok(value) => values.push(value),
                $crate::Result::Err(_) => break
            }
        }

        $crate::Result::Ok(values)
    });
}

#[inline]
pub fn many<I: Input, O, F>(input: &mut I, f: F) -> Result<O, I>
    where F: Fn(&mut I) -> Result<O, I>
{
    loop {
        let output = f(input)?;
        if let Ok(_) = eof(input) {
            return Ok(output);
        }
    }
}

#[inline(always)]
pub fn surrounded<I: Input, O, F, P>(input: &mut I, mut p: P, f: F) -> Result<O, I>
    where F: Copy + FnMut(I::Token) -> bool,
          P: FnMut(&mut I) -> Result<O, I>
{
    skip_while(input, f)?;
    let output = p(input)?;
    skip_while(input, f)?;
    Ok(output)
}