109 lines
2.8 KiB
Rust
109 lines
2.8 KiB
Rust
use crate::parser::{ParseResult, Parser, ParserInput, Representation};
|
|
|
|
pub fn literal_char(expected: char) -> impl Fn(&str) -> ParseResult<&str, char, &str> {
|
|
move |input| match input.chars().next() {
|
|
Some(ch) if ch == expected => Ok((expected, &input[ch.len_utf8()..])),
|
|
_ => Err(input),
|
|
}
|
|
}
|
|
|
|
pub fn literal<'a>(expected: &'static str) -> impl Parser<&'a str, &'a str, &'a str> {
|
|
println!("literal call expected: {}", expected);
|
|
let rep = Representation::new(expected);
|
|
let p = move |input: &'a str| match input.get(0..expected.len()) {
|
|
Some(next) if next == expected => Ok((expected, &input[expected.len()..])),
|
|
_ => Err(input),
|
|
};
|
|
(p, rep)
|
|
}
|
|
|
|
pub fn any_char(input: &str) -> ParseResult<&str, char, &str> {
|
|
match input.chars().next() {
|
|
Some(ch) => Ok((ch, &input[ch.len_utf8()..])),
|
|
None => Err(input),
|
|
}
|
|
}
|
|
|
|
pub fn one_of<'a>(items: &'static str) -> impl Parser<&'a str, &'a str, &'a str> {
|
|
let p = move |input: &'a str| {
|
|
if let Some(ch) = input.chars().next() {
|
|
if items.contains(ch) {
|
|
let (first, rest) = input.split_at(1);
|
|
return Ok((first, rest));
|
|
}
|
|
}
|
|
Err(input)
|
|
};
|
|
|
|
let mut s = String::new();
|
|
for ch in items.chars() {
|
|
s.push(ch);
|
|
s.push_str(" | ");
|
|
}
|
|
let rep = Representation::new(&s);
|
|
(p, rep)
|
|
}
|
|
|
|
pub fn pred<P, F, I, O>(parser: P, pred_fn: F) -> impl Parser<I, O, I>
|
|
where
|
|
I: ParserInput,
|
|
P: Parser<I, O, I>,
|
|
F: Fn(&O) -> bool,
|
|
{
|
|
let orig_rep = parser.representation();
|
|
(
|
|
move |input| {
|
|
parser.parse(input).and_then(|(result, rest)| {
|
|
if pred_fn(&result) {
|
|
Ok((result, rest))
|
|
} else {
|
|
Err(rest)
|
|
}
|
|
})
|
|
},
|
|
Representation::new(&format!("{:?} if <PREDICATE>", orig_rep)),
|
|
)
|
|
}
|
|
|
|
/// Parses a standard identifier in a programming language
|
|
pub fn identifier(input: &str) -> ParseResult<&str, String, &str> {
|
|
let mut chars = input.chars();
|
|
let mut buf = String::new();
|
|
|
|
match chars.next() {
|
|
Some(ch) if ch.is_alphabetic() => buf.push(ch),
|
|
_ => return Err(input),
|
|
}
|
|
|
|
for next in chars {
|
|
if next.is_alphanumeric() {
|
|
buf.push(next);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
let next_index = buf.len();
|
|
Ok((buf, &input[next_index..]))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_identifier() {
|
|
assert_eq!(
|
|
identifier("bongo1beans").unwrap(),
|
|
(("bongo1beans".to_string(), ""))
|
|
);
|
|
assert_eq!(identifier("2bongo1beans"), Err("2bongo1beans"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_pred() {
|
|
let p = pred(any_char, |c| *c == 'f');
|
|
assert_eq!(p.parse("frog"), Ok(('f', "rog")));
|
|
}
|
|
}
|