diff --git a/Cargo.toml b/Cargo.toml index d4f3465..bef8c16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,3 +12,4 @@ edition = "2018" [dependencies] nom = "5.0.0" +str-concat = "*" diff --git a/src/attributes.rs b/src/attributes.rs index 416681b..43152f7 100644 --- a/src/attributes.rs +++ b/src/attributes.rs @@ -55,14 +55,14 @@ mod tests { "{:?}", all_consuming(attribute_instance)("(* full_case=1 *)") ), - "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"])))))) }] }))" + "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))) }] }))" ); assert_eq!( format!( "{:?}", all_consuming(attribute_instance)("(* full_case=1, parallel_case = 0 *)") ), - "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"])))))) }, AttrSpec { attr_name: Identifier { raw: [\"parallel_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"0\"])))))) }] }))" + "Ok((\"\", AttributeInstance { attr_spec: [AttrSpec { attr_name: Identifier { raw: [\"full_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))) }, AttrSpec { attr_name: Identifier { raw: [\"parallel_case\"] }, rvalue: Some(Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"0\")))))) }] }))" ); } } diff --git a/src/lvalues.rs b/src/lvalues.rs index f841a1a..0a6a7aa 100644 --- a/src/lvalues.rs +++ b/src/lvalues.rs @@ -177,15 +177,15 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(net_lvalue)("a[1][2]")), - "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"]))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"2\"])))))], part_select_range: None } })))" + "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } })))" ); assert_eq!( format!("{:?}", all_consuming(net_lvalue)("a[1][10:5]")), - "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"])))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"10\"]))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"5\"])))))))) } })))" + "Ok((\"\", Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"5\")))))))) } })))" ); assert_eq!( format!("{:?}", all_consuming(net_lvalue)("{a, b[1], c}")), - "Ok((\"\", Lvalue([Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"b\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"])))))], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"c\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } })])))" + "Ok((\"\", Lvalue([Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"b\"] } } }, select: ConstantSelect { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: None } }), Identifier(NetLvalueIdentifier { identifier: ScopedIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"c\"] } } }, select: ConstantSelect { member: None, bit_select: [], part_select_range: None } })])))" ); assert_eq!( format!("{:?}", all_consuming(variable_lvalue)("a")), @@ -193,15 +193,15 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(variable_lvalue)("a[1][2]")), - "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"]))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"2\"])))))], part_select_range: None } })))" + "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } })))" ); assert_eq!( format!("{:?}", all_consuming(variable_lvalue)("a[1][10:5]")), - "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"])))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"10\"]))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"5\"])))))))) } })))" + "Ok((\"\", Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: Some(Range((Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"5\")))))))) } })))" ); assert_eq!( format!("{:?}", all_consuming(variable_lvalue)("{a, b[1], c}")), - "Ok((\"\", Lvalue([Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"b\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"])))))], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"c\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } })])))" + "Ok((\"\", Lvalue([Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"b\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\")))))], part_select_range: None } }), Identifier(VariableLvalueIdentifier { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"c\"] } }, select: Select { member: None, bit_select: [], part_select_range: None } })])))" ); assert_eq!( format!("{:?}", all_consuming(nonrange_variable_lvalue)("a")), @@ -209,7 +209,7 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(nonrange_variable_lvalue)("a[1][2]")), - "Ok((\"\", NonrangeVariableLvalue { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"1\"]))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"2\"])))))], part_select_range: None } }))" + "Ok((\"\", NonrangeVariableLvalue { scope: None, identifier: HierarchicalIdentifier { hierarchy: [], identifier: Identifier { raw: [\"a\"] } }, select: Select { member: None, bit_select: [Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"1\"))))), Nullary(PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"2\")))))], part_select_range: None } }))" ); } } diff --git a/src/numbers.rs b/src/numbers.rs index 07ef696..6434663 100644 --- a/src/numbers.rs +++ b/src/numbers.rs @@ -21,7 +21,7 @@ pub enum IntegralNumber<'a> { OctalNumber(OctalNumber<'a>), BinaryNumber(BinaryNumber<'a>), HexNumber(HexNumber<'a>), - UnsignedNumber(Vec<&'a str>), + UnsignedNumber(&'a str), } #[derive(Debug)] @@ -32,45 +32,45 @@ pub enum RealNumber<'a> { #[derive(Debug)] pub struct DecimalNumber<'a> { - pub size: Option>, + pub size: Option<&'a str>, pub decimal_base: &'a str, - pub decimal_value: Vec<&'a str>, + pub decimal_value: &'a str, } #[derive(Debug)] pub struct BinaryNumber<'a> { - pub size: Option>, + pub size: Option<&'a str>, pub binary_base: &'a str, - pub binary_value: Vec<&'a str>, + pub binary_value: &'a str, } #[derive(Debug)] pub struct OctalNumber<'a> { - pub size: Option>, + pub size: Option<&'a str>, pub octal_base: &'a str, - pub octal_value: Vec<&'a str>, + pub octal_value: &'a str, } #[derive(Debug)] pub struct HexNumber<'a> { - pub size: Option>, + pub size: Option<&'a str>, pub hex_base: &'a str, - pub hex_value: Vec<&'a str>, + pub hex_value: &'a str, } #[derive(Debug)] pub struct FixedPointNumber<'a> { - pub integer_value: Vec<&'a str>, - pub fraction_value: Vec<&'a str>, + pub integer_value: &'a str, + pub fraction_value: &'a str, } #[derive(Debug)] pub struct FloatingPointNumber<'a> { - pub integer_value: Vec<&'a str>, - pub fraction_value: Option>, + pub integer_value: &'a str, + pub fraction_value: Option<&'a str>, pub exponent: &'a str, pub sign: Option<&'a str>, - pub exponent_value: Vec<&'a str>, + pub exponent_value: &'a str, } // ----------------------------------------------------------------------------- @@ -149,13 +149,11 @@ pub fn hex_number(s: &str) -> IResult<&str, IntegralNumber> { )) } -pub fn size(s: &str) -> IResult<&str, Vec<&str>> { +pub fn size(s: &str) -> IResult<&str, &str> { let (s, x) = is_a("123456789")(s)?; - let (s, x) = fold_many0(alt((tag("_"), digit1)), vec![x], |mut acc: Vec<_>, item| { - acc.push(item); - acc - })(s)?; - Ok((s, x)) + fold_many0(alt((tag("_"), digit1)), x, |acc, item| { + str_concat::concat(acc, item).unwrap() + })(s) } pub fn real_number(s: &str) -> IResult<&str, Number> { @@ -196,47 +194,33 @@ pub fn floating_point_number(s: &str) -> IResult<&str, RealNumber> { )) } -pub fn unsigned_number(s: &str) -> IResult<&str, Vec<&str>> { +pub fn unsigned_number(s: &str) -> IResult<&str, &str> { let (s, x) = digit1(s)?; - fold_many0(alt((tag("_"), digit1)), vec![x], |mut acc: Vec<_>, item| { - acc.push(item); - acc + fold_many0(alt((tag("_"), digit1)), x, |acc, item| { + str_concat::concat(acc, item).unwrap() })(s) } -pub fn binary_value(s: &str) -> IResult<&str, Vec<&str>> { +pub fn binary_value(s: &str) -> IResult<&str, &str> { let (s, x) = is_a("01xXzZ?")(s)?; - fold_many0( - alt((tag("_"), is_a("01xXzZ?"))), - vec![x], - |mut acc: Vec<_>, item| { - acc.push(item); - acc - }, - )(s) + fold_many0(alt((tag("_"), is_a("01xXzZ?"))), x, |acc, item| { + str_concat::concat(acc, item).unwrap() + })(s) } -pub fn octal_value(s: &str) -> IResult<&str, Vec<&str>> { +pub fn octal_value(s: &str) -> IResult<&str, &str> { let (s, x) = is_a("01234567xXzZ?")(s)?; - fold_many0( - alt((tag("_"), is_a("01234567xXzZ?"))), - vec![x], - |mut acc: Vec<_>, item| { - acc.push(item); - acc - }, - )(s) + fold_many0(alt((tag("_"), is_a("01234567xXzZ?"))), x, |acc, item| { + str_concat::concat(acc, item).unwrap() + })(s) } -pub fn hex_value(s: &str) -> IResult<&str, Vec<&str>> { +pub fn hex_value(s: &str) -> IResult<&str, &str> { let (s, x) = is_a("0123456789abcdefABCDEFxXzZ?")(s)?; fold_many0( alt((tag("_"), is_a("0123456789abcdefABCDEFxXzZ?"))), - vec![x], - |mut acc: Vec<_>, item| { - acc.push(item); - acc - }, + x, + |acc, item| str_concat::concat(acc, item).unwrap(), )(s) } @@ -256,28 +240,18 @@ pub fn hex_base(s: &str) -> IResult<&str, &str> { alt((tag_no_case("'h"), tag_no_case("'sh")))(s) } -pub fn x_number(s: &str) -> IResult<&str, Vec<&str>> { +pub fn x_number(s: &str) -> IResult<&str, &str> { let (s, x) = tag_no_case("x")(s)?; - fold_many0( - alt((tag("_"), is_a("_"))), - vec![x], - |mut acc: Vec<_>, item| { - acc.push(item); - acc - }, - )(s) + fold_many0(alt((tag("_"), is_a("_"))), x, |acc, item| { + str_concat::concat(acc, item).unwrap() + })(s) } -pub fn z_number(s: &str) -> IResult<&str, Vec<&str>> { +pub fn z_number(s: &str) -> IResult<&str, &str> { let (s, x) = alt((tag_no_case("z"), tag("?")))(s)?; - fold_many0( - alt((tag("_"), is_a("_"))), - vec![x], - |mut acc: Vec<_>, item| { - acc.push(item); - acc - }, - )(s) + fold_many0(alt((tag("_"), is_a("_"))), x, |acc, item| { + str_concat::concat(acc, item).unwrap() + })(s) } pub fn unbased_unsized_literal(s: &str) -> IResult<&str, &str> { @@ -294,15 +268,15 @@ mod tests { fn test() { assert_eq!( format!("{:?}", all_consuming(number)("659")), - "Ok((\"\", IntegralNumber(UnsignedNumber([\"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\"] }))))" + "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\"] }))))" + "Ok((\"\", IntegralNumber(OctalNumber(OctalNumber { size: None, octal_base: \"\\\'o\", octal_value: \"7460\" }))))" ); assert_eq!( format!("{:?}", all_consuming(number)("4af")), @@ -310,23 +284,23 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(number)("4'b1001")), - "Ok((\"\", IntegralNumber(BinaryNumber(BinaryNumber { size: Some([\"4\"]), binary_base: \"\\\'b\", binary_value: [\"1001\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some(\"16\"), hex_base: \"\\\'h\", hex_value: \"z\" }))))" ); assert_eq!( format!("{:?}", all_consuming(number)("8 'd -6")), @@ -334,59 +308,59 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(number)("4 'shf")), - "Ok((\"\", IntegralNumber(HexNumber(HexNumber { size: Some([\"4\"]), hex_base: \"\\\'sh\", hex_value: [\"f\"] }))))" + "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: [\"?\"] }))))" + "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\"]))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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\"] }))))" + "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")), diff --git a/src/primaries.rs b/src/primaries.rs index 96cd9a3..732cee8 100644 --- a/src/primaries.rs +++ b/src/primaries.rs @@ -168,7 +168,7 @@ pub enum ImplicitClassHandle { #[derive(Debug)] pub struct UnsignedTimeLiteral<'a> { - number: Vec<&'a str>, + number: &'a str, unit: TimeUnit, } @@ -627,11 +627,11 @@ mod tests { fn test() { assert_eq!( format!("{:?}", all_consuming(primary)("2.1ns")), - "Ok((\"\", PrimaryLiteral(TimeLiteral(FixedPointTimeLiteral(FixedPointTimeLiteral { number: FixedPointNumber(FixedPointNumber { integer_value: [\"2\"], fraction_value: [\"1\"] }), unit: NS })))))" + "Ok((\"\", PrimaryLiteral(TimeLiteral(FixedPointTimeLiteral(FixedPointTimeLiteral { number: FixedPointNumber(FixedPointNumber { integer_value: \"2\", fraction_value: \"1\" }), unit: NS })))))" ); assert_eq!( format!("{:?}", all_consuming(primary)("40 ps")), - "Ok((\"\", PrimaryLiteral(TimeLiteral(UnsignedTimeLiteral(UnsignedTimeLiteral { number: [\"40\"], unit: PS })))))" + "Ok((\"\", PrimaryLiteral(TimeLiteral(UnsignedTimeLiteral(UnsignedTimeLiteral { number: \"40\", unit: PS })))))" ); assert_eq!( format!("{:?}", all_consuming(primary)("'0")), @@ -639,7 +639,7 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(primary)("10")), - "Ok((\"\", PrimaryLiteral(Number(IntegralNumber(UnsignedNumber([\"10\"]))))))" + "Ok((\"\", PrimaryLiteral(Number(IntegralNumber(UnsignedNumber(\"10\"))))))" ); assert_eq!( format!("{:?}", all_consuming(primary)("\"aaa\"")), @@ -663,7 +663,7 @@ mod tests { ); assert_eq!( format!("{:?}", all_consuming(module_path_primary)("10")), - "Ok((\"\", Number(IntegralNumber(UnsignedNumber([\"10\"])))))" + "Ok((\"\", Number(IntegralNumber(UnsignedNumber(\"10\")))))" ); assert_eq!( format!("{:?}", all_consuming(constant_primary)("null")),