hedgewars: comparison rust/hedgewars-server/src/protocol/parser.rs

equal deleted inserted replaced

-:7c4d6246a531
+:0e59abde6766
 */
 use nom::{
 branch::alt,
 bytes::complete::{tag, tag_no_case, take_until, take_while},
 character::complete::{newline, not_line_ending},
-combinator::peek,
+combinator::{map, peek},
 error::{ErrorKind, ParseError},
 multi::separated_list,
-sequence::{pairc, precededc, terminatedc},
+sequence::{pair, preceded, terminated},
 Err, IResult,
 };
 use std::{
 num::ParseIntError,
 Err(Err::Error(HwProtocolError::new()))
 }
 }
 fn a_line(input: &[u8]) -> HwResult<String> {
-let (i, str) = str_line(input)?;
+map(str_line, String::from)(input)
-Ok((i, str.to_string()))
-}
-fn hw_tag<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HwResult<'a, ()> {
-move |i| tag(tag_str)(i).map(|(i, _)| (i, ()))
-}
-fn hw_tag_no_case<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HwResult<'a, ()> {
-move |i| tag_no_case(tag_str)(i).map(|(i, _)| (i, ()))
 }
 fn cmd_arg(input: &[u8]) -> HwResult<String> {
 let delimiters = b" \n";
 let (i, str) = take_while(move |c| !delimiters.contains(&c))(input.clone())?;
 Ok((i, convert_from_str(str)?.1))
 }
 fn yes_no_line(input: &[u8]) -> HwResult<bool> {
 alt((
-|i| tag_no_case(b"YES")(i).map(|(i, _)| (i, true)),
+map(tag_no_case(b"YES"), |_| true),
-|i| tag_no_case(b"NO")(i).map(|(i, _)| (i, false)),
+map(tag_no_case(b"NO"), |_| false),
 ))(input)
 }
 fn opt_arg<'a>(input: &'a [u8]) -> HwResult<'a, Option<String>> {
 alt((
-|i| peek(end_of_message)(i).map(|(i, _)| (i, None)),
+map(peek(end_of_message), |_| None),
-|i| precededc(i, hw_tag("\n"), a_line).map(|(i, v)| (i, Some(v))),
+map(preceded(tag("\n"), a_line), Some),
 ))(input)
 }
 fn spaces(input: &[u8]) -> HwResult<&[u8]> {
-precededc(input, hw_tag(" "), |i| take_while(|c| c == b' ')(i))
+preceded(tag(" "), take_while(|c| c == b' '))(input)
 }
 fn opt_space_arg<'a>(input: &'a [u8]) -> HwResult<'a, Option<String>> {
 alt((
-|i| peek(end_of_message)(i).map(|(i, _)| (i, None)),
+map(peek(end_of_message), |_| None),
-|i| precededc(i, spaces, a_line).map(|(i, v)| (i, Some(v))),
+map(preceded(spaces, a_line), Some),
 ))(input)
 }
 fn hedgehog_array(input: &[u8]) -> HwResult<[HedgehogInfo; 8]> {
 fn hedgehog_line(input: &[u8]) -> HwResult<HedgehogInfo> {
-let (i, name) = terminatedc(input, a_line, newline)?;
+let (i, name) = terminated(a_line, newline)(input)?;
 let (i, hat) = a_line(i)?;
 Ok((i, HedgehogInfo { name, hat }))
 }
-let (i, h1) = terminatedc(input, hedgehog_line, newline)?;
+let (i, h1) = terminated(hedgehog_line, newline)(input)?;
-let (i, h2) = terminatedc(i, hedgehog_line, newline)?;
+let (i, h2) = terminated(hedgehog_line, newline)(i)?;
-let (i, h3) = terminatedc(i, hedgehog_line, newline)?;
+let (i, h3) = terminated(hedgehog_line, newline)(i)?;
-let (i, h4) = terminatedc(i, hedgehog_line, newline)?;
+let (i, h4) = terminated(hedgehog_line, newline)(i)?;
-let (i, h5) = terminatedc(i, hedgehog_line, newline)?;
+let (i, h5) = terminated(hedgehog_line, newline)(i)?;
-let (i, h6) = terminatedc(i, hedgehog_line, newline)?;
+let (i, h6) = terminated(hedgehog_line, newline)(i)?;
-let (i, h7) = terminatedc(i, hedgehog_line, newline)?;
+let (i, h7) = terminated(hedgehog_line, newline)(i)?;
 let (i, h8) = hedgehog_line(i)?;
 Ok((i, [h1, h2, h3, h4, h5, h6, h7, h8]))
 }
 fn voting(input: &[u8]) -> HwResult<VoteType> {
 alt((
-|i| tag_no_case("PAUSE")(i).map(|(i, _)| (i, VoteType::Pause)),
+map(tag_no_case("PAUSE"), |_| VoteType::Pause),
-|i| tag_no_case("NEWSEED")(i).map(|(i, _)| (i, VoteType::NewSeed)),
+map(tag_no_case("NEWSEED"), |_| VoteType::NewSeed),
-|i| {
+map(
-precededc(i, |i| precededc(i, hw_tag_no_case("KICK"), spaces), a_line)
+preceded(pair(tag_no_case("KICK"), spaces), a_line),
-.map(|(i, s)| (i, VoteType::Kick(s)))
+VoteType::Kick,
-},
+),
-|i| {
+map(
-precededc(
+preceded(pair(tag_no_case("HEDGEHOGS"), spaces), u8_line),
-i,
+VoteType::HedgehogsPerTeam,
-|i| precededc(i, hw_tag_no_case("HEDGEHOGS"), spaces),
+),
-u8_line,
+map(
-)
+preceded(tag_no_case("MAP"), opt_space_arg),
-.map(|(i, n)| (i, VoteType::HedgehogsPerTeam(n)))
+VoteType::Map,
-},
+),
-|i| precededc(i, hw_tag_no_case("MAP"), opt_space_arg).map(|(i, v)| (i, VoteType::Map(v))),
 ))(input)
 }
 fn no_arg_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
 fn messagec<'a>(
 input: &'a [u8],
 name: &'a str,
 msg: HwProtocolMessage,
 ) -> HwResult<'a, HwProtocolMessage> {
-tag(name)(input).map(|(i, _)| (i, msg.clone()))
+map(tag(name), |_| msg.clone())(input)
 }
 alt((
 |i| messagec(i, "PING", Ping),
 |i| messagec(i, "PONG", Pong),
 ) -> HwResult<'a, HwProtocolMessage>
 where
 F: Fn(&[u8]) -> HwResult<T>,
 G: Fn(T) -> HwProtocolMessage,
 {
-precededc(input, hw_tag(name), parser).map(|(i, v)| (i, constructor(v)))
+map(preceded(tag(name), parser), constructor)(input)
 }
 alt((
 |i| messagec(i, "NICK\n", a_line, Nick),
 |i| messagec(i, "INFO\n", a_line, Info),
 fn cmdc_no_arg<'a>(
 input: &'a [u8],
 name: &'a str,
 msg: HwProtocolMessage,
 ) -> HwResult<'a, HwProtocolMessage> {
-tag_no_case(name)(input).map(|(i, _)| (i, msg.clone()))
+map(tag_no_case(name), |_| msg.clone())(input)
 }
 fn cmdc_single_arg<'a, T, F, G>(
 input: &'a [u8],
 name: &'a str,
 ) -> HwResult<'a, HwProtocolMessage>
 where
 F: Fn(&'a [u8]) -> HwResult<'a, T>,
 G: Fn(T) -> HwProtocolMessage,
 {
-precededc(input, |i| pairc(i, hw_tag_no_case(name), spaces), parser)
+map(
-.map(|(i, v)| (i, constructor(v)))
+preceded(pair(tag_no_case(name), spaces), parser),
+constructor,
+)(input)
 }
 fn cmd_no_arg_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
 alt((
 |i| cmdc_no_arg(i, "STATS", Stats),
 |i| cmdc_single_arg(i, "MAXTEAMS", u8_line, MaxTeams),
 |i| cmdc_single_arg(i, "CALLVOTE", voting, |v| CallVote(Some(v))),
 ))(input)
 }
-precededc(
+preceded(
-input,
+tag("CMD\n"),
-hw_tag("CMD\n"),
 alt((
 cmd_no_arg_message,
 cmd_single_arg_message,
-|i| tag_no_case("CALLVOTE")(i).map(|(i, _)| (i, CallVote(None))),
+map(tag_no_case("CALLVOTE"), |_| CallVote(None)),
-|i| {
+map(
-precededc(i, hw_tag_no_case("GREETING"), opt_space_arg)
+preceded(tag_no_case("GREETING"), opt_space_arg),
-.map(|(i, s)| (i, Greeting(s)))
+Greeting,
-},
+),
-|i| precededc(i, hw_tag_no_case("PART"), opt_space_arg).map(|(i, s)| (i, Part(s))),
+map(preceded(tag_no_case("PART"), opt_space_arg), Part),
-|i| precededc(i, hw_tag_no_case("QUIT"), opt_space_arg).map(|(i, s)| (i, Quit(s))),
+map(preceded(tag_no_case("QUIT"), opt_space_arg), Quit),
-|i| {
+map(
-precededc(i, hw_tag_no_case("SAVE"), |i| {
+preceded(
-pairc(
+tag_no_case("SAVE"),
-i,
+pair(preceded(spaces, cmd_arg), preceded(spaces, cmd_arg)),
-|i| precededc(i, spaces, cmd_arg),
+),
-|i| precededc(i, spaces, cmd_arg),
+|(n, l)| Save(n, l),
-)
+),
-})
+map(
-.map(|(i, (n, l))| (i, Save(n, l)))
+preceded(
-},
+tag_no_case("RND"),
-|i| {
+alt((
-let (i, _) = tag_no_case("RND")(i)?;
+map(peek(end_of_message), |_| vec![]),
-let (i, v) = alt((
+preceded(spaces, separated_list(spaces, cmd_arg)),
-|i| peek(end_of_message)(i).map(|(i, _)| (i, vec![])),
+)),
-|i| {
+),
-let (i, _) = spaces(i)?;
+Rnd,
-let (i, v) = separated_list(spaces, cmd_arg)(i)?;
+),
-Ok((i, v))
-},
-))(i)?;
-Ok((i, Rnd(v)))
-},
 )),
-)
+)(input)
 }
 fn config_message<'a>(input: &'a [u8]) -> HwResult<'a, HwProtocolMessage> {
 fn cfgc_single_arg<'a, T, F, G>(
 input: &'a [u8],
 ) -> HwResult<'a, GameCfg>
 where
 F: Fn(&[u8]) -> HwResult<T>,
 G: Fn(T) -> GameCfg,
 {
-precededc(input, |i| terminatedc(i, hw_tag(name), newline), parser)
+map(preceded(pair(tag(name), newline), parser), constructor)(input)
-.map(|(i, v)| (i, constructor(v)))
+}
-}
+let (i, cfg) = preceded(
-let (i, cfg) = precededc(
+tag("CFG\n"),
-input,
-hw_tag("CFG\n"),
 alt((
 |i| cfgc_single_arg(i, "THEME", a_line, GameCfg::Theme),
 |i| cfgc_single_arg(i, "SCRIPT", a_line, GameCfg::Script),
 |i| cfgc_single_arg(i, "MAP", a_line, GameCfg::MapType),
 |i| cfgc_single_arg(i, "MAPGEN", u32_line, GameCfg::MapGenerator),
 |i| cfgc_single_arg(i, "MAZE_SIZE", u32_line, GameCfg::MazeSize),
 |i| cfgc_single_arg(i, "TEMPLATE", u32_line, GameCfg::Template),
 |i| cfgc_single_arg(i, "FEATURE_SIZE", u32_line, GameCfg::FeatureSize),
 |i| cfgc_single_arg(i, "SEED", a_line, GameCfg::Seed),
 |i| cfgc_single_arg(i, "DRAWNMAP", a_line, GameCfg::DrawnMap),
-|i| {
+preceded(pair(tag("AMMO"), newline), |i| {
-precededc(
+let (i, name) = a_line(i)?;
-i,
+let (i, value) = opt_arg(i)?;
-|i| terminatedc(i, hw_tag("AMMO"), newline),
+Ok((i, GameCfg::Ammo(name, value)))
-|i| {
+}),
-let (i, name) = a_line(i)?;
+preceded(pair(tag("SCHEME"), newline), |i| {
-let (i, value) = opt_arg(i)?;
+let (i, name) = a_line(i)?;
-Ok((i, GameCfg::Ammo(name, value)))
+let (i, values) = alt((
-},
+map(peek(end_of_message), |_| None),
-)
+map(preceded(newline, separated_list(newline, a_line)), Some),
-},
+))(i)?;
-|i| {
+Ok((i, GameCfg::Scheme(name, values.unwrap_or_default())))
-precededc(
+}),
-i,
-|i| terminatedc(i, hw_tag("SCHEME"), newline),
-|i| {
-let (i, name) = a_line(i)?;
-let (i, values) = alt((
-|i| peek(end_of_message)(i).map(|(i, _)| (i, None)),
-|i| {
-precededc(i, newline, |i| separated_list(newline, a_line)(i))
-.map(|(i, v)| (i, Some(v)))
-},
-))(i)?;
-Ok((i, GameCfg::Scheme(name, values.unwrap_or_default())))
-},
-)
-},
 )),
-)?;
+)(input)?;
 Ok((i, Cfg(cfg)))
 }
 fn server_var_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
-precededc(
+map(
-input,
+preceded(
-hw_tag("SET_SERVER_VAR\n"),
+tag("SET_SERVER_VAR\n"),
 alt((
-|i| {
+map(preceded(tag("MOTD_NEW\n"), a_line), ServerVar::MOTDNew),
-precededc(i, hw_tag("MOTD_NEW\n"), a_line)
+map(preceded(tag("MOTD_OLD\n"), a_line), ServerVar::MOTDOld),
-.map(|(i, s)| (i, SetServerVar(ServerVar::MOTDNew(s))))
+map(
-},
+preceded(tag("LATEST_PROTO\n"), u16_line),
-|i| {
+ServerVar::LatestProto,
-precededc(i, hw_tag("MOTD_OLD\n"), a_line)
+),
-.map(|(i, s)| (i, SetServerVar(ServerVar::MOTDOld(s))))
+)),
-},
+),
-|i| {
+SetServerVar,
-precededc(i, hw_tag("LATEST_PROTO\n"), u16_line)
+)(input)
-.map(|(i, n)| (i, SetServerVar(ServerVar::LatestProto(n))))
-},
-)),
-)
 }
 fn complex_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
 alt((
-|i| {
+preceded(pair(tag("PASSWORD"), newline), |i| {
-precededc(
+let (i, pass) = terminated(a_line, newline)(i)?;
+let (i, salt) = a_line(i)?;
+Ok((i, Password(pass, salt)))
+}),
+preceded(pair(tag("CHECKER"), newline), |i| {
+let (i, protocol) = terminated(u16_line, newline)(i)?;
+let (i, name) = terminated(a_line, newline)(i)?;
+let (i, pass) = a_line(i)?;
+Ok((i, Checker(protocol, name, pass)))
+}),
+preceded(pair(tag("CREATE_ROOM"), newline), |i| {
+let (i, name) = a_line(i)?;
+let (i, pass) = opt_arg(i)?;
+Ok((i, CreateRoom(name, pass)))
+}),
+preceded(pair(tag("JOIN_ROOM"), newline), |i| {
+let (i, name) = a_line(i)?;
+let (i, pass) = opt_arg(i)?;
+Ok((i, JoinRoom(name, pass)))
+}),
+preceded(pair(tag("ADD_TEAM"), newline), |i| {
+let (i, name) = terminated(a_line, newline)(i)?;
+let (i, color) = terminated(u8_line, newline)(i)?;
+let (i, grave) = terminated(a_line, newline)(i)?;
+let (i, fort) = terminated(a_line, newline)(i)?;
+let (i, voice_pack) = terminated(a_line, newline)(i)?;
+let (i, flag) = terminated(a_line, newline)(i)?;
+let (i, difficulty) = terminated(u8_line, newline)(i)?;
+let (i, hedgehogs) = hedgehog_array(i)?;
+Ok((
 i,
-|i| terminatedc(i, hw_tag("PASSWORD"), newline),
+AddTeam(Box::new(TeamInfo {
-|i| {
+owner: String::new(),
-let (i, pass) = terminatedc(i, a_line, newline)?;
+name,
-let (i, salt) = a_line(i)?;
+color,
-Ok((i, Password(pass, salt)))
+grave,
-},
+fort,
-)
+voice_pack,
-},
+flag,
-|i| {
+difficulty,
-precededc(
+hedgehogs,
-i,
+hedgehogs_number: 0,
-|i| terminatedc(i, hw_tag("CHECKER"), newline),
+})),
-|i| {
+))
-let (i, protocol) = terminatedc(i, u16_line, newline)?;
+}),
-let (i, name) = terminatedc(i, a_line, newline)?;
+preceded(pair(tag("HH_NUM"), newline), |i| {
-let (i, pass) = a_line(i)?;
+let (i, name) = terminated(a_line, newline)(i)?;
-Ok((i, Checker(protocol, name, pass)))
+let (i, count) = u8_line(i)?;
-},
+Ok((i, SetHedgehogsNumber(name, count)))
-)
+}),
-},
+preceded(pair(tag("TEAM_COLOR"), newline), |i| {
-|i| {
+let (i, name) = terminated(a_line, newline)(i)?;
-precededc(
+let (i, color) = u8_line(i)?;
-i,
+Ok((i, SetTeamColor(name, color)))
-|i| terminatedc(i, hw_tag("CREATE_ROOM"), newline),
+}),
-|i| {
+preceded(pair(tag("BAN"), newline), |i| {
-let (i, name) = a_line(i)?;
+let (i, n) = terminated(a_line, newline)(i)?;
-let (i, pass) = opt_arg(i)?;
+let (i, r) = terminated(a_line, newline)(i)?;
-Ok((i, CreateRoom(name, pass)))
+let (i, t) = u32_line(i)?;
-},
+Ok((i, Ban(n, r, t)))
-)
+}),
-},
+preceded(pair(tag("BAN_IP"), newline), |i| {
-|i| {
+let (i, n) = terminated(a_line, newline)(i)?;
-precededc(
+let (i, r) = terminated(a_line, newline)(i)?;
-i,
+let (i, t) = u32_line(i)?;
-|i| terminatedc(i, hw_tag("JOIN_ROOM"), newline),
+Ok((i, BanIP(n, r, t)))
-|i| {
+}),
-let (i, name) = a_line(i)?;
+preceded(pair(tag("BAN_NICK"), newline), |i| {
-let (i, pass) = opt_arg(i)?;
+let (i, n) = terminated(a_line, newline)(i)?;
-Ok((i, JoinRoom(name, pass)))
+let (i, r) = terminated(a_line, newline)(i)?;
-},
+let (i, t) = u32_line(i)?;
-)
+Ok((i, BanNick(n, r, t)))
-},
+}),
-|i| {
-precededc(
-i,
-|i| terminatedc(i, hw_tag("ADD_TEAM"), newline),
-|i| {
-let (i, name) = terminatedc(i, a_line, newline)?;
-let (i, color) = terminatedc(i, u8_line, newline)?;
-let (i, grave) = terminatedc(i, a_line, newline)?;
-let (i, fort) = terminatedc(i, a_line, newline)?;
-let (i, voice_pack) = terminatedc(i, a_line, newline)?;
-let (i, flag) = terminatedc(i, a_line, newline)?;
-let (i, difficulty) = terminatedc(i, u8_line, newline)?;
-let (i, hedgehogs) = hedgehog_array(i)?;
-Ok((
-i,
-AddTeam(Box::new(TeamInfo {
-owner: String::new(),
-name,
-color,
-grave,
-fort,
-voice_pack,
-flag,
-difficulty,
-hedgehogs,
-hedgehogs_number: 0,
-})),
-))
-},
-)
-},
-|i| {
-precededc(
-i,
-|i| terminatedc(i, hw_tag("HH_NUM"), newline),
-|i| {
-let (i, name) = terminatedc(i, a_line, newline)?;
-let (i, count) = u8_line(i)?;
-Ok((i, SetHedgehogsNumber(name, count)))
-},
-)
-},
-|i| {
-precededc(
-i,
-|i| terminatedc(i, hw_tag("TEAM_COLOR"), newline),
-|i| {
-let (i, name) = terminatedc(i, a_line, newline)?;
-let (i, color) = u8_line(i)?;
-Ok((i, SetTeamColor(name, color)))
-},
-)
-},
-|i| {
-precededc(
-i,
-|i| terminatedc(i, hw_tag("BAN"), newline),
-|i| {
-let (i, n) = terminatedc(i, a_line, newline)?;
-let (i, r) = terminatedc(i, a_line, newline)?;
-let (i, t) = u32_line(i)?;
-Ok((i, Ban(n, r, t)))
-},
-)
-},
-|i| {
-precededc(
-i,
-|i| terminatedc(i, hw_tag("BAN_IP"), newline),
-|i| {
-let (i, n) = terminatedc(i, a_line, newline)?;
-let (i, r) = terminatedc(i, a_line, newline)?;
-let (i, t) = u32_line(i)?;
-Ok((i, BanIP(n, r, t)))
-},
-)
-},
-|i| {
-precededc(
-i,
-|i| terminatedc(i, hw_tag("BAN_NICK"), newline),
-|i| {
-let (i, n) = terminatedc(i, a_line, newline)?;
-let (i, r) = terminatedc(i, a_line, newline)?;
-let (i, t) = u32_line(i)?;
-Ok((i, BanNick(n, r, t)))
-},
-)
-},
 ))(input)
 }
 pub fn malformed_message(input: &[u8]) -> HwResult<()> {
-let (i, _) = terminatedc(input, |i| take_until(&b"\n\n"[..])(i), end_of_message)?;
+map(terminated(take_until(&b"\n\n"[..]), end_of_message), |_| ())(input)
-Ok((i, ()))
 }
 pub fn message(input: &[u8]) -> HwResult<HwProtocolMessage> {
-precededc(
+preceded(
-input,
+take_while(|c| c == b'\n'),
-|i| take_while(|c| c == b'\n')(i),
+terminated(
-|i| {
+alt((
-terminatedc(
+no_arg_message,
-i,
+single_arg_message,
-alt((
+cmd_message,
-no_arg_message,
+config_message,
-single_arg_message,
+server_var_message,
-cmd_message,
+complex_message,
-config_message,
+)),
-server_var_message,
+end_of_message,
-complex_message,
+),
-)),
+)(input)
-end_of_message,
-)
-},
-)
 }
 #[cfg(test)]
 mod test {
 use super::message;

changeset 15118	0e59abde6766
parent 15116	cce6e707172f
child 15119	901751d3cd80