538 lines
17 KiB
Rust
538 lines
17 KiB
Rust
use crate::parser::*;
|
|
use nom::branch::*;
|
|
use nom::bytes::complete::*;
|
|
use nom::character::complete::*;
|
|
use nom::combinator::*;
|
|
use nom::multi::*;
|
|
use nom::sequence::*;
|
|
use nom::IResult;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#[derive(Debug)]
|
|
pub enum Number<'a> {
|
|
IntegralNumber(IntegralNumber<'a>),
|
|
RealNumber(RealNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum IntegralNumber<'a> {
|
|
DecimalNumber(DecimalNumber<'a>),
|
|
OctalNumber(OctalNumber<'a>),
|
|
BinaryNumber(BinaryNumber<'a>),
|
|
HexNumber(HexNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum DecimalNumber<'a> {
|
|
UnsignedNumber(UnsignedNumber<'a>),
|
|
BaseUnsigned(DecimalNumberBaseUnsigned<'a>),
|
|
BaseXNumber(DecimalNumberBaseXNumber<'a>),
|
|
BaseZNumber(DecimalNumberBaseZNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct DecimalNumberBaseUnsigned<'a> {
|
|
pub nodes: (Option<Size<'a>>, DecimalBase<'a>, UnsignedNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct DecimalNumberBaseXNumber<'a> {
|
|
pub nodes: (Option<Size<'a>>, DecimalBase<'a>, XNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct DecimalNumberBaseZNumber<'a> {
|
|
pub nodes: (Option<Size<'a>>, DecimalBase<'a>, ZNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct BinaryNumber<'a> {
|
|
pub nodes: (Option<Size<'a>>, BinaryBase<'a>, BinaryValue<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct OctalNumber<'a> {
|
|
pub nodes: (Option<Size<'a>>, OctalBase<'a>, OctalValue<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct HexNumber<'a> {
|
|
pub nodes: (Option<Size<'a>>, HexBase<'a>, HexValue<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Sign<'a> {
|
|
Plus(Symbol<'a>),
|
|
Minus(Symbol<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Size<'a> {
|
|
pub nodes: (NonZeroUnsignedNumber<'a>,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct NonZeroUnsignedNumber<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RealNumber<'a> {
|
|
FixedPointNumber(FixedPointNumber<'a>),
|
|
Floating(RealNumberFloating<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct RealNumberFloating<'a> {
|
|
pub nodes: (
|
|
UnsignedNumber<'a>,
|
|
Option<(Symbol<'a>, UnsignedNumber<'a>)>,
|
|
Exp<'a>,
|
|
Option<Sign<'a>>,
|
|
UnsignedNumber<'a>,
|
|
),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct FixedPointNumber<'a> {
|
|
pub nodes: (UnsignedNumber<'a>, Symbol<'a>, UnsignedNumber<'a>),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Exp<'a> {
|
|
pub nodes: (Symbol<'a>,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct UnsignedNumber<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct BinaryValue<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct OctalValue<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct HexValue<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct DecimalBase<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct BinaryBase<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct OctalBase<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct HexBase<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct XNumber<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ZNumber<'a> {
|
|
pub nodes: (&'a str,),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct UnbasedUnsizedLiteral<'a> {
|
|
pub nodes: (Symbol<'a>,),
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
pub fn number(s: &str) -> IResult<&str, Number> {
|
|
alt((
|
|
map(real_number, |x| Number::RealNumber(x)),
|
|
map(integral_number, |x| Number::IntegralNumber(x)),
|
|
))(s)
|
|
}
|
|
|
|
pub fn integral_number(s: &str) -> IResult<&str, IntegralNumber> {
|
|
alt((
|
|
map(octal_number, |x| IntegralNumber::OctalNumber(x)),
|
|
map(binary_number, |x| IntegralNumber::BinaryNumber(x)),
|
|
map(hex_number, |x| IntegralNumber::HexNumber(x)),
|
|
map(decimal_number, |x| IntegralNumber::DecimalNumber(x)),
|
|
))(s)
|
|
}
|
|
|
|
pub fn decimal_number(s: &str) -> IResult<&str, DecimalNumber> {
|
|
alt((
|
|
map(unsigned_number, |x| DecimalNumber::UnsignedNumber(x)),
|
|
decimal_number_base_unsigned,
|
|
decimal_number_base_x_number,
|
|
decimal_number_base_z_number,
|
|
))(s)
|
|
}
|
|
|
|
pub fn decimal_number_base_unsigned(s: &str) -> IResult<&str, DecimalNumber> {
|
|
let (s, a) = opt(size)(s)?;
|
|
let (s, b) = decimal_base(s)?;
|
|
let (s, c) = unsigned_number(s)?;
|
|
Ok((
|
|
s,
|
|
DecimalNumber::BaseUnsigned(DecimalNumberBaseUnsigned { nodes: (a, b, c) }),
|
|
))
|
|
}
|
|
|
|
pub fn decimal_number_base_x_number(s: &str) -> IResult<&str, DecimalNumber> {
|
|
let (s, a) = opt(size)(s)?;
|
|
let (s, b) = decimal_base(s)?;
|
|
let (s, c) = x_number(s)?;
|
|
Ok((
|
|
s,
|
|
DecimalNumber::BaseXNumber(DecimalNumberBaseXNumber { nodes: (a, b, c) }),
|
|
))
|
|
}
|
|
|
|
pub fn decimal_number_base_z_number(s: &str) -> IResult<&str, DecimalNumber> {
|
|
let (s, a) = opt(size)(s)?;
|
|
let (s, b) = decimal_base(s)?;
|
|
let (s, c) = z_number(s)?;
|
|
Ok((
|
|
s,
|
|
DecimalNumber::BaseZNumber(DecimalNumberBaseZNumber { nodes: (a, b, c) }),
|
|
))
|
|
}
|
|
|
|
pub fn binary_number(s: &str) -> IResult<&str, BinaryNumber> {
|
|
let (s, a) = opt(size)(s)?;
|
|
let (s, b) = binary_base(s)?;
|
|
let (s, c) = binary_value(s)?;
|
|
Ok((s, BinaryNumber { nodes: (a, b, c) }))
|
|
}
|
|
|
|
pub fn octal_number(s: &str) -> IResult<&str, OctalNumber> {
|
|
let (s, a) = opt(size)(s)?;
|
|
let (s, b) = octal_base(s)?;
|
|
let (s, c) = octal_value(s)?;
|
|
Ok((s, OctalNumber { nodes: (a, b, c) }))
|
|
}
|
|
|
|
pub fn hex_number(s: &str) -> IResult<&str, HexNumber> {
|
|
let (s, a) = opt(size)(s)?;
|
|
let (s, b) = hex_base(s)?;
|
|
let (s, c) = hex_value(s)?;
|
|
Ok((s, HexNumber { nodes: (a, b, c) }))
|
|
}
|
|
|
|
pub fn sign(s: &str) -> IResult<&str, Sign> {
|
|
alt((
|
|
map(symbol("+"), |x| Sign::Plus(x)),
|
|
map(symbol("-"), |x| Sign::Minus(x)),
|
|
))(s)
|
|
}
|
|
|
|
pub fn size(s: &str) -> IResult<&str, Size> {
|
|
let (s, a) = non_zero_unsigned_number(s)?;
|
|
Ok((s, Size { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn non_zero_unsigned_number(s: &str) -> IResult<&str, NonZeroUnsignedNumber> {
|
|
let (s, a) = ws(non_zero_unsigned_number_impl)(s)?;
|
|
Ok((s, NonZeroUnsignedNumber { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn non_zero_unsigned_number_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = is_a("123456789")(s)?;
|
|
fold_many0(alt((tag("_"), digit1)), a, |acc, item| {
|
|
str_concat::concat(acc, item).unwrap()
|
|
})(s)
|
|
}
|
|
|
|
pub fn real_number(s: &str) -> IResult<&str, RealNumber> {
|
|
alt((
|
|
real_number_floating,
|
|
map(fixed_point_number, |x| RealNumber::FixedPointNumber(x)),
|
|
))(s)
|
|
}
|
|
|
|
pub fn real_number_floating(s: &str) -> IResult<&str, RealNumber> {
|
|
let (s, a) = unsigned_number(s)?;
|
|
let (s, b) = opt(pair(symbol("."), unsigned_number))(s)?;
|
|
let (s, c) = exp(s)?;
|
|
let (s, d) = opt(sign)(s)?;
|
|
let (s, e) = unsigned_number(s)?;
|
|
Ok((
|
|
s,
|
|
RealNumber::Floating(RealNumberFloating {
|
|
nodes: (a, b, c, d, e),
|
|
}),
|
|
))
|
|
}
|
|
|
|
pub fn fixed_point_number(s: &str) -> IResult<&str, FixedPointNumber> {
|
|
let (s, a) = unsigned_number(s)?;
|
|
let (s, b) = map(tag("."), |x| Symbol { nodes: (x,) })(s)?;;
|
|
let (s, c) = unsigned_number(s)?;
|
|
Ok((s, FixedPointNumber { nodes: (a, b, c) }))
|
|
}
|
|
|
|
pub fn exp(s: &str) -> IResult<&str, Exp> {
|
|
let (s, a) = alt((symbol("e"), symbol("E")))(s)?;
|
|
Ok((s, Exp { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn unsigned_number(s: &str) -> IResult<&str, UnsignedNumber> {
|
|
let (s, a) = ws(unsigned_number_impl)(s)?;
|
|
Ok((s, UnsignedNumber { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn unsigned_number_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = digit1(s)?;
|
|
fold_many0(alt((tag("_"), digit1)), a, |acc, item| {
|
|
str_concat::concat(acc, item).unwrap()
|
|
})(s)
|
|
}
|
|
|
|
pub fn binary_value(s: &str) -> IResult<&str, BinaryValue> {
|
|
let (s, a) = ws(binary_value_impl)(s)?;
|
|
Ok((s, BinaryValue { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn binary_value_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = is_a("01xXzZ?")(s)?;
|
|
fold_many0(alt((tag("_"), is_a("01xXzZ?"))), a, |acc, item| {
|
|
str_concat::concat(acc, item).unwrap()
|
|
})(s)
|
|
}
|
|
|
|
pub fn octal_value(s: &str) -> IResult<&str, OctalValue> {
|
|
let (s, a) = ws(octal_value_impl)(s)?;
|
|
Ok((s, OctalValue { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn octal_value_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = is_a("01234567xXzZ?")(s)?;
|
|
fold_many0(alt((tag("_"), is_a("01234567xXzZ?"))), a, |acc, item| {
|
|
str_concat::concat(acc, item).unwrap()
|
|
})(s)
|
|
}
|
|
|
|
pub fn hex_value(s: &str) -> IResult<&str, HexValue> {
|
|
let (s, a) = ws(hex_value_impl)(s)?;
|
|
Ok((s, HexValue { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn hex_value_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?;
|
|
fold_many0(
|
|
alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))),
|
|
a,
|
|
|acc, item| str_concat::concat(acc, item).unwrap(),
|
|
)(s)
|
|
}
|
|
|
|
pub fn decimal_base(s: &str) -> IResult<&str, DecimalBase> {
|
|
let (s, a) = ws(decimal_base_impl)(s)?;
|
|
Ok((s, DecimalBase { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn decimal_base_impl(s: &str) -> IResult<&str, &str> {
|
|
alt((tag_no_case("'d"), tag_no_case("'sd")))(s)
|
|
}
|
|
|
|
pub fn binary_base(s: &str) -> IResult<&str, BinaryBase> {
|
|
let (s, a) = ws(binary_base_impl)(s)?;
|
|
Ok((s, BinaryBase { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn binary_base_impl(s: &str) -> IResult<&str, &str> {
|
|
alt((tag_no_case("'b"), tag_no_case("'sb")))(s)
|
|
}
|
|
|
|
pub fn octal_base(s: &str) -> IResult<&str, OctalBase> {
|
|
let (s, a) = ws(octal_base_impl)(s)?;
|
|
Ok((s, OctalBase { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn octal_base_impl(s: &str) -> IResult<&str, &str> {
|
|
alt((tag_no_case("'o"), tag_no_case("'so")))(s)
|
|
}
|
|
|
|
pub fn hex_base(s: &str) -> IResult<&str, HexBase> {
|
|
let (s, a) = ws(hex_base_impl)(s)?;
|
|
Ok((s, HexBase { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn hex_base_impl(s: &str) -> IResult<&str, &str> {
|
|
alt((tag_no_case("'h"), tag_no_case("'sh")))(s)
|
|
}
|
|
|
|
pub fn x_number(s: &str) -> IResult<&str, XNumber> {
|
|
let (s, a) = ws(x_number_impl)(s)?;
|
|
Ok((s, XNumber { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn x_number_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = tag_no_case("x")(s)?;
|
|
fold_many0(alt((tag("_"), is_a("_"))), a, |acc, item| {
|
|
str_concat::concat(acc, item).unwrap()
|
|
})(s)
|
|
}
|
|
|
|
pub fn z_number(s: &str) -> IResult<&str, ZNumber> {
|
|
let (s, a) = ws(z_number_impl)(s)?;
|
|
Ok((s, ZNumber { nodes: (a,) }))
|
|
}
|
|
|
|
pub fn z_number_impl(s: &str) -> IResult<&str, &str> {
|
|
let (s, a) = alt((tag_no_case("z"), tag("?")))(s)?;
|
|
fold_many0(alt((tag("_"), is_a("_"))), a, |acc, item| {
|
|
str_concat::concat(acc, item).unwrap()
|
|
})(s)
|
|
}
|
|
|
|
pub fn unbased_unsized_literal(s: &str) -> IResult<&str, UnbasedUnsizedLiteral> {
|
|
let (s, a) = alt((symbol("'0"), symbol("'1"), symbol("'z"), symbol("'x")))(s)?;
|
|
Ok((s, UnbasedUnsizedLiteral { nodes: (a,) }))
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test() {
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("659")),
|
|
"Ok((\"\", IntegralNumber(UnsignedNumber(\"659\"))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("'h 837FF")),
|
|
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: None, hex_base: \"\\\'h\", hex_value: \"837FF\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("'o7460")),
|
|
"Ok((\"\", IntegralNumber(OctalNumber(OctalNumber { size: None, octal_base: \"\\\'o\", octal_value: \"7460\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("4af")),
|
|
"Err(Error((\"af\", Eof)))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("4'b1001")),
|
|
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some(\"4\"), binary_base: \"\\\'b\", binary_value: \"1001\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("5 'D 3")),
|
|
"Ok((\"\", IntegralNumber(DecimalNumber(DecimalNumber { size: Some(\"5\"), decimal_base: \"\\\'D\", decimal_value: \"3\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("3'b01x")),
|
|
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some(\"3\"), binary_base: \"\\\'b\", binary_value: \"01x\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("12'hx")),
|
|
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"12\"), hex_base: \"\\\'h\", hex_value: \"x\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("16'hz")),
|
|
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"16\"), hex_base: \"\\\'h\", hex_value: \"z\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("8 'd -6")),
|
|
"Err(Error((\"\\\'d -6\", Eof)))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("4 'shf")),
|
|
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"4\"), hex_base: \"\\\'sh\", hex_value: \"f\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("16'sd?")),
|
|
"Ok((\"\", IntegralNumber(DecimalNumber(DecimalNumber { size: Some(\"16\"), decimal_base: \"\\\'sd\", decimal_value: \"?\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("27_195_000")),
|
|
"Ok((\"\", IntegralNumber(UnsignedNumber(\"27_195_000\"))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("16'b0011_0101_0001_1111")),
|
|
"Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some(\"16\"), binary_base: \"\\\'b\", binary_value: \"0011_0101_0001_1111\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("32 'h 12ab_f001")),
|
|
"Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"32\"), hex_base: \"\\\'h\", hex_value: \"12ab_f001\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("1.2")),
|
|
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: \"1\", fraction_value: \"2\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("0.1")),
|
|
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: \"0\", fraction_value: \"1\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("2394.26331")),
|
|
"Ok((\"\", RealNumber(FixedPointNumber(FixedPointNumber { integer_value: \"2394\", fraction_value: \"26331\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("1.2E12")),
|
|
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"1\", fraction_value: Some(\"2\"), exponent: \"E\", sign: None, exponent_value: \"12\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("1.30e-2")),
|
|
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"1\", fraction_value: Some(\"30\"), exponent: \"e\", sign: Some(\"-\"), exponent_value: \"2\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("0.1e-0")),
|
|
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"0\", fraction_value: Some(\"1\"), exponent: \"e\", sign: Some(\"-\"), exponent_value: \"0\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("23E10")),
|
|
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"23\", fraction_value: None, exponent: \"E\", sign: None, exponent_value: \"10\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("29E-2")),
|
|
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"29\", fraction_value: None, exponent: \"E\", sign: Some(\"-\"), exponent_value: \"2\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("236.123_763_e-12")),
|
|
"Ok((\"\", RealNumber(FloatingPointNumber(FloatingPointNumber { integer_value: \"236\", fraction_value: Some(\"123_763_\"), exponent: \"e\", sign: Some(\"-\"), exponent_value: \"12\" }))))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)(".12")),
|
|
"Err(Error((\".12\", Digit)))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("9.")),
|
|
"Err(Error((\".\", Eof)))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)("4.E3")),
|
|
"Err(Error((\".E3\", Eof)))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(number)(".2e-7")),
|
|
"Err(Error((\".2e-7\", Digit)))"
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", all_consuming(unbased_unsized_literal)("'0")),
|
|
"Ok((\"\", \"\\\'0\"))"
|
|
);
|
|
}
|
|
}
|