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
use crate::{
error::Result,
types::{ParserOutput, RawOutputConcat},
ParseError, ParseIter, Parser,
};
#[derive(Clone, Copy)]
pub struct SequenceParser<Head, Tail> {
head: Head,
tail: Tail,
}
pub struct SequenceParseIter<'parse, 'source, Head, Tail>
where
Head: Parser<'parse, 'source>,
Tail: Parser<'parse, 'source>,
{
parsers: &'parse SequenceParser<Head, Tail>,
is_at_start: bool,
source: &'source str,
start: usize,
head_iter: Option<Head::Iter>,
tail_iter: Option<Tail::Iter>,
}
impl<'parse, 'source, Head, Tail> Parser<'parse, 'source> for SequenceParser<Head, Tail>
where
Head: Parser<'parse, 'source> + 'parse,
Tail: Parser<'parse, 'source> + 'parse,
Head::RawOutput: RawOutputConcat<Tail::RawOutput>,
{
type Output =
<<Head::RawOutput as RawOutputConcat<Tail::RawOutput>>::Output as ParserOutput>::UserType;
type RawOutput = <Head::RawOutput as RawOutputConcat<Tail::RawOutput>>::Output;
type Iter = SequenceParseIter<'parse, 'source, Head, Tail>;
fn parse_iter(&'parse self, source: &'source str, start: usize) -> Self::Iter {
SequenceParseIter {
parsers: self,
is_at_start: true,
source,
start,
head_iter: None,
tail_iter: None,
}
}
}
impl<'parse, 'source, Head, Tail> ParseIter for SequenceParseIter<'parse, 'source, Head, Tail>
where
Head: Parser<'parse, 'source>,
Tail: Parser<'parse, 'source>,
Head::RawOutput: RawOutputConcat<Tail::RawOutput>,
{
type RawOutput = <Head::RawOutput as RawOutputConcat<Tail::RawOutput>>::Output;
fn next_parse(&mut self) -> Option<Result<usize>> {
let mut foremost_error: Option<ParseError> = None;
loop {
if let Some(tail_iter) = &mut self.tail_iter {
match tail_iter.next_parse() {
None => {}
Some(Err(err)) => {
if foremost_error.as_ref().map(|err| err.location) < Some(err.location) {
foremost_error = Some(err);
}
}
Some(Ok(tail_end)) => return Some(Ok(tail_end)),
}
self.tail_iter = None;
} else if let Some(head_iter) = &mut self.head_iter {
match head_iter.next_parse() {
None => {}
Some(Err(err)) => {
if foremost_error.as_ref().map(|err| err.location) < Some(err.location) {
foremost_error = Some(err);
}
}
Some(Ok(head_end)) => {
self.tail_iter = Some(self.parsers.tail.parse_iter(self.source, head_end));
continue;
}
}
self.head_iter = None;
return foremost_error.map(Err);
} else if self.is_at_start {
self.is_at_start = false;
self.head_iter = Some(self.parsers.head.parse_iter(self.source, self.start));
} else {
return None;
}
}
}
fn take_data(&mut self) -> Self::RawOutput {
let head = self.head_iter.as_mut().unwrap().take_data();
let tail = self.tail_iter.as_mut().unwrap().take_data();
head.concat(tail)
}
}
pub fn sequence<Head, Tail>(head: Head, tail: Tail) -> SequenceParser<Head, Tail> {
SequenceParser { head, tail }
}