153 lines
4.3 KiB
Rust
153 lines
4.3 KiB
Rust
use logos::Logos;
|
|
use super::session::ReportMode;
|
|
|
|
#[derive(Logos, Debug, PartialEq)]
|
|
enum Token {
|
|
#[end]
|
|
End,
|
|
#[error]
|
|
Error,
|
|
|
|
#[token = "Quit"]
|
|
Quit,
|
|
#[token = "show"]
|
|
Show,
|
|
#[token = "channel"]
|
|
Channel,
|
|
#[token = "report"]
|
|
Report,
|
|
#[token = "mode"]
|
|
Mode,
|
|
#[token = "off"]
|
|
Off,
|
|
#[token = "once"]
|
|
Once,
|
|
#[token = "continuous"]
|
|
Continuous,
|
|
#[token = "enable"]
|
|
Enable,
|
|
#[token = "disable"]
|
|
Disable,
|
|
#[token = "setup"]
|
|
Setup,
|
|
|
|
#[regex = "[0-9]+"]
|
|
Number,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Error {
|
|
Parser,
|
|
UnexpectedEnd,
|
|
UnexpectedToken(Token),
|
|
NoSuchChannel,
|
|
NoSuchSetup,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum ShowCommand {
|
|
ReportMode,
|
|
}
|
|
|
|
|
|
#[derive(Debug)]
|
|
pub enum ChannelCommand {
|
|
Enable,
|
|
Disable,
|
|
Setup(u8),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Command {
|
|
Quit,
|
|
Show(ShowCommand),
|
|
Report(ReportMode),
|
|
Channel(u8, ChannelCommand),
|
|
}
|
|
|
|
const CHANNEL_IDS: &'static [&'static str] = &[
|
|
"0", "1", "2", "3",
|
|
];
|
|
const SETUP_IDS: &'static [&'static str] = CHANNEL_IDS;
|
|
|
|
impl Command {
|
|
pub fn parse(input: &str) -> Result<Self, Error> {
|
|
let mut lexer = Token::lexer(input);
|
|
|
|
/// Match against a set of expected tokens
|
|
macro_rules! choice {
|
|
[$($token: tt => $block: stmt,)*] => {
|
|
match lexer.token {
|
|
$(
|
|
Token::$token => {
|
|
lexer.advance();
|
|
$block
|
|
}
|
|
)*
|
|
Token::End => Err(Error::UnexpectedEnd),
|
|
_ => Err(Error::UnexpectedToken(lexer.token))
|
|
}
|
|
};
|
|
}
|
|
/// Expecting no further tokens
|
|
macro_rules! end {
|
|
($result: expr) => {
|
|
match lexer.token {
|
|
Token::End => Ok($result),
|
|
_ => Err(Error::UnexpectedToken(lexer.token)),
|
|
}
|
|
};
|
|
}
|
|
|
|
// Command grammar
|
|
choice![
|
|
Quit => Ok(Command::Quit),
|
|
Report => choice![
|
|
Mode => choice![
|
|
End => end!(Command::Show(ShowCommand::ReportMode)),
|
|
Off => Ok(Command::Report(ReportMode::Off)),
|
|
Once => Ok(Command::Report(ReportMode::Once)),
|
|
Continuous => Ok(Command::Report(ReportMode::Continuous)),
|
|
],
|
|
End => Ok(Command::Report(ReportMode::Once)),
|
|
],
|
|
Channel => choice![
|
|
Number => {
|
|
let channel = CHANNEL_IDS.iter()
|
|
.position(|id| *id == lexer.slice());
|
|
match channel {
|
|
Some(channel) => {
|
|
choice![
|
|
Enable => Ok(Command::Channel(
|
|
channel as u8,
|
|
ChannelCommand::Enable
|
|
)),
|
|
Disable => Ok(Command::Channel(
|
|
channel as u8,
|
|
ChannelCommand::Enable
|
|
)),
|
|
Setup => choice![
|
|
Number => {
|
|
let setup = SETUP_IDS.iter()
|
|
.position(|id| *id == lexer.slice());
|
|
match setup {
|
|
Some(setup) =>
|
|
end!(Command::Channel(
|
|
channel as u8,
|
|
ChannelCommand::Setup(setup as u8)
|
|
)),
|
|
None =>
|
|
Err(Error::NoSuchSetup)
|
|
}
|
|
},
|
|
],
|
|
]
|
|
}
|
|
None => Err(Error::NoSuchChannel)
|
|
}
|
|
},
|
|
],
|
|
]
|
|
}
|
|
}
|