use crate::{
parsers::{BasicParseIter, MapParser},
ParseContext, ParseIter, Parser, Reported, Result,
};
#[derive(Clone, Copy)]
pub struct CharParser {
noun: &'static str,
predicate: fn(char) -> bool,
}
pub struct CharParseIter {
c: char,
end: usize,
}
#[derive(Clone, Copy)]
pub struct CharOfParser {
options: &'static str,
}
impl Parser for CharParser {
type Output = char;
type RawOutput = (char,);
type Iter<'parse> = CharParseIter;
fn parse_iter<'parse>(
&'parse self,
context: &mut ParseContext<'parse>,
start: usize,
) -> Result<Self::Iter<'parse>, Reported> {
match context.source()[start..].chars().next() {
Some(c) if (self.predicate)(c) => Ok(CharParseIter {
c,
end: start + c.len_utf8(),
}),
_ => Err(context.error_expected(start, self.noun)),
}
}
}
impl<'parse> ParseIter<'parse> for CharParseIter {
type RawOutput = (char,);
fn match_end(&self) -> usize {
self.end
}
fn backtrack(&mut self, _context: &mut ParseContext<'parse>) -> Result<(), Reported> {
Err(Reported)
}
fn convert(&self) -> (char,) {
(self.c,)
}
}
impl Parser for CharOfParser {
type Output = usize;
type RawOutput = (usize,);
type Iter<'parse> = BasicParseIter<usize>;
fn parse_iter<'parse>(
&'parse self,
context: &mut ParseContext<'parse>,
start: usize,
) -> Result<Self::Iter<'parse>, Reported> {
if let Some(c) = context.source()[start..].chars().next() {
for (i, x) in self.options.chars().enumerate() {
if c == x {
return Ok(BasicParseIter {
value: i,
end: start + c.len_utf8(),
});
}
}
}
Err(context.error_expected(start, &format!("one of {:?}", self.options)))
}
}
#[allow(non_upper_case_globals)]
pub const alpha: CharParser = CharParser {
noun: "letter",
predicate: char::is_alphabetic,
};
#[allow(non_upper_case_globals)]
pub const alnum: CharParser = CharParser {
noun: "letter or digit",
predicate: char::is_alphanumeric,
};
#[allow(non_upper_case_globals)]
pub const upper: CharParser = CharParser {
noun: "uppercase letter",
predicate: char::is_uppercase,
};
#[allow(non_upper_case_globals)]
pub const lower: CharParser = CharParser {
noun: "lowercase letter",
predicate: char::is_lowercase,
};
#[allow(non_upper_case_globals)]
pub const any_char: CharParser = CharParser {
noun: "any character",
predicate: |_| true,
};
#[allow(non_upper_case_globals)]
pub const digit: MapParser<CharParser, fn(char) -> usize> = MapParser {
inner: CharParser {
noun: "decimal digit",
predicate: |c| c.is_ascii_digit(),
},
mapper: |c| c.to_digit(10).unwrap() as usize,
};
#[allow(non_upper_case_globals)]
pub const digit_bin: MapParser<CharParser, fn(char) -> usize> = MapParser {
inner: CharParser {
noun: "hexadecimal digit",
predicate: |c| c.is_digit(2),
},
mapper: |c| c.to_digit(2).unwrap() as usize,
};
#[allow(non_upper_case_globals, clippy::is_digit_ascii_radix)]
pub const digit_hex: MapParser<CharParser, fn(char) -> usize> = MapParser {
inner: CharParser {
noun: "hexadecimal digit",
predicate: |c| c.is_digit(16),
},
mapper: |c| c.to_digit(16).unwrap() as usize,
};
pub fn char_of(options: &'static str) -> CharOfParser {
CharOfParser { options }
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testing::*;
#[test]
fn test_char_of() {
assert_parse_eq(char_of("<=>"), "<", 0);
assert_parse_eq(char_of("<=>"), ">", 2);
assert_parse_error(char_of("<=>"), "", "expected one of \"<=>\"");
assert_parse_error(
char_of("<=>"),
" <",
"expected one of \"<=>\" at line 1 column 1",
);
assert_parse_eq(char_of("DCBA"), "D", 0);
assert_parse_eq(char_of("DCBA"), "C", 1);
assert_parse_error(char_of("DCBA"), "DC", "at line 1 column 2");
assert_parse_error(char_of(""), "", "expected one of \"\"");
assert_parse_eq(char_of("😂😃🌍"), "🌍", 2);
assert_parse_error(char_of("😂😃🌍"), "L", "expected one of \"😂😃🌍\"");
}
}