86 lines
2.1 KiB
Rust
86 lines
2.1 KiB
Rust
use std::fmt;
|
|
|
|
use crate::util::intersperse_option;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Representation {
|
|
production_output: EBNF,
|
|
}
|
|
|
|
impl Representation {
|
|
pub fn show(&self) -> String {
|
|
self.production_output.to_string()
|
|
}
|
|
|
|
pub fn production(&self) -> EBNF {
|
|
self.production_output.clone()
|
|
}
|
|
|
|
pub fn new() -> Self {
|
|
Self {
|
|
production_output: EBNF::None,
|
|
}
|
|
}
|
|
|
|
pub fn with_production(self, production_output: EBNF) -> Self {
|
|
Self {
|
|
production_output,
|
|
..self
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum EBNF {
|
|
None,
|
|
Nonterminal(String),
|
|
CharTerminal(char),
|
|
StringTerminal(String),
|
|
Alternation(Vec<EBNF>),
|
|
}
|
|
|
|
impl fmt::Display for EBNF {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
EBNF::None => write!(f, "none"),
|
|
EBNF::CharTerminal(ch) => write!(f, "'{ch}'"),
|
|
EBNF::Alternation(items) => {
|
|
for item in intersperse_option(items.iter()) {
|
|
match item {
|
|
None => write!(f, " | ")?,
|
|
Some(item) => write!(f, "{item}")?,
|
|
}
|
|
}
|
|
write!(f, "")
|
|
}
|
|
EBNF::Nonterminal(name) => write!(f, "{name}"),
|
|
EBNF::StringTerminal(term) => write!(f, r#""{term}""#),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_ebnf_print() {
|
|
let example = EBNF::Alternation(vec![
|
|
EBNF::CharTerminal('f'),
|
|
EBNF::CharTerminal('a'),
|
|
EBNF::CharTerminal('k'),
|
|
EBNF::CharTerminal('e'),
|
|
]);
|
|
|
|
assert_eq!(example.to_string(), "'f' | 'a' | 'k' | 'e'");
|
|
|
|
let example = EBNF::Alternation(vec![
|
|
EBNF::Nonterminal("other-rule".into()),
|
|
EBNF::CharTerminal('q'),
|
|
EBNF::CharTerminal('m'),
|
|
EBNF::StringTerminal("focus".into()),
|
|
]);
|
|
assert_eq!(example.to_string(), "other-rule | 'q' | 'm' | \"focus\"");
|
|
}
|
|
}
|