328 lines
9 KiB
Rust
328 lines
9 KiB
Rust
use nom::{
|
|
branch::alt,
|
|
bytes::complete::tag,
|
|
character::complete::{
|
|
alphanumeric1, i8, multispace0, multispace1, newline, none_of, not_line_ending, space1,
|
|
},
|
|
combinator::{all_consuming, map, opt, recognize, rest},
|
|
error::{context, convert_error, VerboseError},
|
|
multi::{many0, many1},
|
|
number::complete::float,
|
|
sequence::{preceded, separated_pair, terminated},
|
|
Err as NomErr, IResult, Parser,
|
|
};
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
pub enum Command {
|
|
Exit,
|
|
SetPos(f32, f32),
|
|
GetPos,
|
|
Move(Direction, i8),
|
|
Stop,
|
|
Park,
|
|
SetConf(String, String),
|
|
Reset,
|
|
GetInfo,
|
|
DumpState,
|
|
DumpCaps,
|
|
SendCmd(String),
|
|
}
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
pub enum Direction {
|
|
UP,
|
|
DOWN,
|
|
CW,
|
|
CCW,
|
|
}
|
|
|
|
fn exit(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("q"), tag("Q"))), |_| Command::Exit).parse(input)
|
|
}
|
|
|
|
fn float_pair(input: &str) -> IResult<&str, (f32, f32), VerboseError<&str>> {
|
|
context("float_pair", separated_pair(float, multispace1, float)).parse(input)
|
|
}
|
|
|
|
fn set_pos(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
context(
|
|
"set_pos",
|
|
map(
|
|
preceded(
|
|
terminated(alt((tag("set_pos"), tag("P"))), multispace1),
|
|
float_pair,
|
|
),
|
|
|pair: (f32, f32)| Command::SetPos(pair.0, pair.1),
|
|
),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn get_pos(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("get_pos"), tag("p"))), |_| Command::GetPos).parse(input)
|
|
}
|
|
|
|
fn direction(input: &str) -> IResult<&str, Direction, VerboseError<&str>> {
|
|
context(
|
|
"direction",
|
|
alt((
|
|
map(alt((tag("UP"), tag("2"))), |_| Direction::UP),
|
|
map(alt((tag("DOWN"), tag("4"))), |_| Direction::DOWN),
|
|
map(alt((tag("CCW"), tag("LEFT"), tag("8"))), |_| Direction::CCW),
|
|
map(alt((tag("CW"), tag("RIGHT"), tag("16"))), |_| Direction::CW),
|
|
)),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn move_parameters(input: &str) -> IResult<&str, (Direction, i8), VerboseError<&str>> {
|
|
context(
|
|
"move_parameters",
|
|
separated_pair(direction, multispace1, i8),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn move_command(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
context(
|
|
"move",
|
|
map(
|
|
preceded(
|
|
terminated(alt((tag("move"), tag("M"))), multispace1),
|
|
move_parameters,
|
|
),
|
|
|pair: (Direction, i8)| Command::Move(pair.0, pair.1),
|
|
),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn stop(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("stop"), tag("S"))), |_| Command::Stop).parse(input)
|
|
}
|
|
|
|
fn park(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("park"), tag("K"))), |_| Command::Park).parse(input)
|
|
}
|
|
|
|
fn string_pair(input: &str) -> IResult<&str, (&str, &str), VerboseError<&str>> {
|
|
// TODO: find out if alphanumeric1 is enough. Might need -_ and others
|
|
context(
|
|
"string_pair",
|
|
separated_pair(alphanumeric1, multispace1, alphanumeric1),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn set_conf(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
context(
|
|
"set_comf",
|
|
map(
|
|
preceded(
|
|
terminated(alt((tag("set_conf"), tag("C"))), multispace1),
|
|
string_pair,
|
|
),
|
|
|pair: (&str, &str)| Command::SetConf(pair.0.to_owned(), pair.1.to_owned()),
|
|
),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn reset(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("reset"), tag("R"))), |_| Command::Reset).parse(input)
|
|
}
|
|
|
|
fn get_info(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("get_info"), tag("_"))), |_| Command::GetInfo).parse(input)
|
|
}
|
|
|
|
fn dump_state(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(tag("dump_state"), |_| Command::DumpState).parse(input)
|
|
}
|
|
|
|
fn dump_caps(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
map(alt((tag("dump_caps"), tag("1"))), |_| Command::DumpCaps).parse(input)
|
|
}
|
|
|
|
fn send_cmd(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
context(
|
|
"send_cmd",
|
|
map(
|
|
preceded(
|
|
terminated(alt((tag("send_cmd"), tag("w"))), space1),
|
|
many1(none_of("#\n")),
|
|
),
|
|
|rest: Vec<char>| Command::SendCmd(rest.iter().collect()),
|
|
),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn command(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
context(
|
|
"command",
|
|
alt((
|
|
exit,
|
|
set_pos,
|
|
park,
|
|
get_pos,
|
|
move_command,
|
|
stop,
|
|
set_conf,
|
|
reset,
|
|
get_info,
|
|
dump_state,
|
|
dump_caps,
|
|
send_cmd,
|
|
)),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn comment(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
|
|
context(
|
|
"comment",
|
|
recognize(preceded(multispace0, preceded(tag("#"), not_line_ending))),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
fn line(input: &str) -> IResult<&str, Command, VerboseError<&str>> {
|
|
context(
|
|
"line",
|
|
all_consuming(terminated(terminated(command, opt(comment)), newline)),
|
|
)
|
|
.parse(input)
|
|
}
|
|
|
|
pub fn parse_command(input: &str) -> Result<Command, String> {
|
|
let result = line(input);
|
|
match result {
|
|
Ok(("", cmd)) => Ok(cmd),
|
|
Ok((rest, _)) => Err("Unable to parse rest".to_owned()),
|
|
Err(err) => match err {
|
|
NomErr::Incomplete(_) => Err("Command was incomplete".to_owned()),
|
|
NomErr::Error(err) | NomErr::Failure(err) => Err(convert_error(input, err)),
|
|
},
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use nom::Err as NomErr;
|
|
|
|
fn assert_command(input: &str, expected: Command) {
|
|
let result = line(input);
|
|
match result {
|
|
Ok(("", cmd)) => assert_eq!(cmd, expected),
|
|
Err(err) => match err {
|
|
NomErr::Incomplete(_) => panic!("Command was incomplete"),
|
|
NomErr::Error(err) | NomErr::Failure(err) => {
|
|
panic!("{}", convert_error(input, err))
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_exit() {
|
|
assert_command("Q\n", Command::Exit);
|
|
assert_command("q\n", Command::Exit);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_pos() {
|
|
assert_command("set_pos 180.0 10.0\n", Command::SetPos(180.0, 10.0));
|
|
assert_command("P 180.0 10.0\n", Command::SetPos(180.0, 10.0));
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_pos() {
|
|
assert_command("get_pos\n", Command::GetPos);
|
|
assert_command("p\n", Command::GetPos);
|
|
}
|
|
|
|
#[test]
|
|
fn test_move() {
|
|
assert_command("M UP 100\n", Command::Move(Direction::UP, 100));
|
|
assert_command("M DOWN -1\n", Command::Move(Direction::DOWN, -1));
|
|
assert_command("M CCW 42\n", Command::Move(Direction::CCW, 42));
|
|
assert_command("M LEFT 42\n", Command::Move(Direction::CCW, 42));
|
|
assert_command("M CW 42\n", Command::Move(Direction::CW, 42));
|
|
assert_command("M RIGHT 42\n", Command::Move(Direction::CW, 42));
|
|
assert_command("move UP 100\n", Command::Move(Direction::UP, 100));
|
|
}
|
|
|
|
#[test]
|
|
fn test_stop() {
|
|
assert_command("stop\n", Command::Stop);
|
|
assert_command("S\n", Command::Stop);
|
|
}
|
|
|
|
#[test]
|
|
fn test_park() {
|
|
assert_command("park\n", Command::Park);
|
|
assert_command("K\n", Command::Park);
|
|
}
|
|
|
|
#[test]
|
|
fn test_reset() {
|
|
assert_command("reset\n", Command::Reset);
|
|
assert_command("R\n", Command::Reset);
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_info() {
|
|
assert_command("get_info\n", Command::GetInfo);
|
|
assert_command("_\n", Command::GetInfo);
|
|
}
|
|
|
|
#[test]
|
|
fn test_dump_state() {
|
|
assert_command("dump_state\n", Command::DumpState);
|
|
}
|
|
|
|
#[test]
|
|
fn test_dump_caps() {
|
|
assert_command("dump_caps\n", Command::DumpCaps);
|
|
assert_command("1\n", Command::DumpCaps);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_conf() {
|
|
assert_command(
|
|
"set_conf foo bar\n",
|
|
Command::SetConf("foo".to_owned(), "bar".to_owned()),
|
|
);
|
|
assert_command(
|
|
"C foo bar\n",
|
|
Command::SetConf("foo".to_owned(), "bar".to_owned()),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_send_cmd() {
|
|
assert_command("send_cmd foo bar\n", Command::SendCmd("foo bar".to_owned()));
|
|
assert_command("w foo bar\n", Command::SendCmd("foo bar".to_owned()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_comments() {
|
|
assert_command(
|
|
"set_pos 180.0 10.0 # fooo bar lol test\n",
|
|
Command::SetPos(180.0, 10.0),
|
|
);
|
|
assert_command(
|
|
"P 180.0 10.0 # fooo bar lol test\n",
|
|
Command::SetPos(180.0, 10.0),
|
|
);
|
|
|
|
// TODO: figure out if the trailing space is a problem
|
|
assert_command(
|
|
"send_cmd foo bar # this is a comment\n",
|
|
Command::SendCmd("foo bar ".to_owned()),
|
|
);
|
|
}
|
|
}
|