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
use crate::{
error::Result,
parsers::{star, EmptyParser, RepeatParser},
types::ParserOutput,
ParseError, ParseIter, Parser,
};
#[derive(Copy, Clone)]
pub struct LineParser<P> {
parser: P,
}
impl<'parse, 'source, P> Parser<'parse, 'source> for LineParser<P>
where
P: Parser<'parse, 'source> + 'parse,
{
type RawOutput = (P::Output,);
type Output = P::Output;
type Iter = LineParseIter<'parse, 'source, P>;
fn parse_iter(&'parse self, source: &'source str, start: usize) -> Self::Iter {
LineParseIter::Init {
parser: self,
source,
start,
}
}
}
pub enum LineParseIter<'parse, 'source, P>
where
P: Parser<'parse, 'source>,
{
Init {
parser: &'parse LineParser<P>,
source: &'source str,
start: usize,
},
Matched {
iter: P::Iter,
},
Done,
}
fn is_at_line_start(source: &str, start: usize) -> bool {
start == 0 || source[..start].ends_with('\n')
}
impl<'parse, 'source, P> ParseIter for LineParseIter<'parse, 'source, P>
where
P: Parser<'parse, 'source>,
{
type RawOutput = (P::Output,);
fn next_parse(&mut self) -> Option<Result<usize>> {
match *self {
LineParseIter::Init {
parser,
source,
start,
} => {
if !is_at_line_start(source, start) {
*self = LineParseIter::Done;
return Some(Err(ParseError::new_bad_line_start(source, start)));
}
let end = match source[start..].find('\n') {
Some(i) => start + i,
None => {
*self = LineParseIter::Done;
return Some(Err(ParseError::new_expected(source, source.len(), "\n")));
}
};
let mut iter = parser.parser.parse_iter(&source[start..end], 0);
let mut farthest = 0;
loop {
match iter.next_parse() {
None => {
*self = LineParseIter::Done;
return Some(Err(ParseError::new_line_extra(source, start + farthest)));
}
Some(Err(err)) => {
*self = LineParseIter::Done;
return Some(Err(err));
}
Some(Ok(len)) if start + len == end => {
*self = LineParseIter::Matched { iter };
return Some(Ok(end + 1));
}
Some(Ok(len)) => farthest = farthest.max(len),
}
}
}
_ => {
*self = LineParseIter::Done;
None
}
}
}
fn take_data(&mut self) -> Self::RawOutput {
match self {
LineParseIter::Matched { iter } => {
let v = iter.take_data().into_user_type();
*self = LineParseIter::Done;
(v,)
}
_ => panic!("internal error: take_data called in invalid state"),
}
}
}
pub fn line<P>(parser: P) -> LineParser<P> {
LineParser { parser }
}
pub fn lines<P>(parser: P) -> RepeatParser<LineParser<P>, EmptyParser> {
star(line(parser))
}