File size: 2,848 Bytes
b98ffbb |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 |
use anyhow::{ensure, Result};
use nom::{
bytes::complete::is_not,
character::complete::{char, space0, space1},
combinator::{eof, recognize},
multi::separated_list1,
sequence::tuple,
};
use super::{error::RclMsgError, ident, literal, types};
use crate::types::{primitives::PrimitiveType, Constant, ConstantType};
fn validate_value(r#type: ConstantType, value: &str) -> Result<Vec<String>> {
match r#type {
ConstantType::PrimitiveType(t) => match t {
PrimitiveType::BasicType(t) => {
let (rest, value) = literal::get_basic_type_literal_parser(t)(value)
.map_err(|_| RclMsgError::ParseConstantValueError(value.into()))?;
ensure!(rest.is_empty());
Ok(vec![value])
}
PrimitiveType::GenericUnboundedString(t) => {
let (rest, default) = literal::get_string_literal_parser(t.into())(value)
.map_err(|_| RclMsgError::ParseDefaultValueError(value.into()))?;
ensure!(rest.is_empty());
Ok(vec![default])
}
},
ConstantType::PrimitiveArray(array_t) => match array_t.value_type {
PrimitiveType::BasicType(t) => {
let (rest, values) = literal::basic_type_sequence(t, value)
.map_err(|_| RclMsgError::ParseDefaultValueError(value.into()))?;
ensure!(rest.is_empty());
ensure!(values.len() == array_t.size);
Ok(values)
}
PrimitiveType::GenericUnboundedString(_) => {
let (rest, values) = literal::string_literal_sequence(value)
.map_err(|_| RclMsgError::ParseDefaultValueError(value.into()))?;
ensure!(rest.is_empty());
Ok(values)
}
},
}
}
pub fn constant_def(line: &str) -> Result<Constant> {
let (_, (r#type, _, name, _, _, _, value, _, _)) = tuple((
types::parse_constant_type,
space1,
ident::constant_name,
space0,
char('='),
space0,
recognize(separated_list1(space1, is_not(" \t"))),
space0,
eof,
))(line)
.map_err(|e| RclMsgError::ParseConstantError {
reason: e.to_string(),
input: line.into(),
})?;
Ok(Constant {
name: name.into(),
r#type: r#type.clone(),
value: validate_value(r#type, value)?,
})
}
#[cfg(test)]
mod test {
use super::*;
use crate::types::primitives::BasicType;
#[test]
fn parse_member_def_with_default() -> Result<()> {
let result = constant_def("int32 AAA=30")?;
assert_eq!(result.name, "AAA");
assert_eq!(result.r#type, BasicType::I32.into());
assert_eq!(result.value, vec!["30"]);
Ok(())
}
}
|